It doesn&#x27;t particularly matter. The loop:<p><pre><code>  a, b = some input arrays of identical length
  c = the output array
  for(int i = 0; i &lt; c.length; i++)
    c[i] = a[i]+b[i]
</code></pre>
can be easily run in parallel, each iteration of the loop kernel is independent of every other iteration. And, with OpenMP a #pragma could make that loop run in parallel without any difficulty (long time since I&#x27;ve used it, forgotten the actual code needed to make it happen but it&#x27;s easy).<p><pre><code>  vector_sum([],[]) -&gt; [];
  vector_sum([A|Atail],[B|Btail]) -&gt; [A+B|vector_sum(Atail,Btail)]
</code></pre>
(it&#x27;s been a while since I erlanged, probably messed up the syntax)<p>Each iteration should be independent, but the way we&#x27;ve constructed it it&#x27;s not easily transformed to run in parallel now. In fact, that&#x27;s a bad construction because erlang <i>does</i> have TCE and that recursion isn&#x27;t in tail-call form.<p>EDIT: Also, iteration and recursion are transformable to each other. If you have a language with tail-call elimination, then recursive code with tail-calls should be equivalent to code using more conventional loop structures.<p>If no data needs to be retained between the recursive calls (consider this probably bad code):<p><pre><code>  int[] vector_add(int[] A,B,C, int index) {
    if(index == C.length) return C;
    C[index] = A[index]+B[index];
    return vector_add(A,B,C,index++);
  }
</code></pre>
assuming A,B, and C are all initialized correctly outside this call, it&#x27;s fundamentally identical to (with TCE, actual assembly may not be the same without a bit more care taken in defining the function):<p><pre><code>  int[] vector_add(int[] A,B,C) {
    for(int i = 0; i &lt; C.length; i++)
      C[i] = A[i] + B[i];
    return C;
  }
</code></pre>
That&#x27;s a trivial transformation. Now, if we need to somehow retain some data (like an accumulator) it&#x27;s not much harder:<p><pre><code>  int factorial(int N) {
    int result = 1;
    for(int i = 1; i &lt;= N; i++)
      result *= i;
    return result;
  }

  int factorial(int N, int result) {
    if(N = 0) return result;
    return factorial(N-1, result*N);
  }
</code></pre>
call the second one as factorial(N, 1), you&#x27;d likely have a wrapper to abstract that out for any user so they only have to call factorial(N).<p>What if the recursion isn&#x27;t a tail-call, how can we transform it? (bad factorial):<p><pre><code>  int bad_factorial(N) {
    if (N == 0) return 1;
    return N * bad_factorial(N-1);
  }
</code></pre>
Assuming we want to keep this stack, the equivalent code with a loop would be like:<p><pre><code>  int bad_factorial(N) {
    int result = 1;
    Stack values = new Stack();
    for(; N &gt; 0; N--)
      values.push(N);
    while(!values.isEmpty())
      result = values.pop();
    return result;
  }
</code></pre>
That stack we&#x27;ve created replaces the program stack that was used implicitly in the recursive version. I won&#x27;t guarantee the performance or assembly is identical (they won&#x27;t be) but they&#x27;re on the same order for both execution time and memory use.