Based on my understanding, it seems that using a case expression for pattern matching, rather than a function head, prevents the automated analyzer from detecting tail recursion.
From what I've read, using a single function head with at top-level case expression for pattern matching should result in essentially the same thing as using multiple function heads, once they are compiled. If that's correct, then it seems the analyzer should be able to detect tail recursion in the case expression variant shown (commented out) below.
It's also possible that there's a gap in my understanding and having the recursive call "wrapped" in a case expression results in a solution that isn't tail-recursive. 😄
def encode(dna) do
_encode(dna, <<>>)
end
# The analyzer says this function IS NOT tail recursive
# defp _encode(dna, acc) do
# case dna do
# [] -> acc
# [c | rest] -> _encode(rest, <<acc::bits, encode_nucleotide(c)::4>>)
# end
# end
# The analyzer says this function IS tail recursive
defp _encode([], acc), do: acc
defp _encode([c | rest], acc), do: _encode(rest, <<acc::bits, encode_nucleotide(c)::4>>)
Based on my understanding, it seems that using a
caseexpression for pattern matching, rather than a function head, prevents the automated analyzer from detecting tail recursion.From what I've read, using a single function head with at top-level
caseexpression for pattern matching should result in essentially the same thing as using multiple function heads, once they are compiled. If that's correct, then it seems the analyzer should be able to detect tail recursion in thecaseexpression variant shown (commented out) below.It's also possible that there's a gap in my understanding and having the recursive call "wrapped" in a
caseexpression results in a solution that isn't tail-recursive. 😄