Mmm, no? A lot of languages have TCO support, not just the beam, it’s actually quite common…
Oracle’s JVM doesn’t, but some others do.
OvermindDL1
flashup4all
def interest_calculator(interest, amount, no_of_days) do
interest_per_day = ((interest/100)/30) |> Float.floor(4)
amount_interest_per_day = interest_per_day * amount
total_balance = amount_interest_per_day + amount
case no_of_days > 0 do
true -> calculator(interest, total_balance, no_of_days-1)
false -> amount
end
end
0
silverdr
In real life I can use while(some_condition) for repeating an action unknown number of times. Like:
do {
name = generate_new_name();
} while(name.exists?)
So I can’t really do any sort of enumeration here. Should I do the recursion in such case? And if I wanted to limit the depth?
0
kip
ex_cldr Core Team
In the simplest terms I think this would be similar to your code above:
def while(fun) when is_function(fun) do
if (name = fun.() && exists?(name)), do: while(fun), else: name
end
# Call it as:
name = while(&generate_name/1)
0
benwilson512
Author of Craft GraphQL APIs in Elixir with Absinthe
Your code example here implies mutation, so “real life” may look a little differently in a functional language. For example if you want to generate a list of new names until they stop existing you can do something like:
Stream.repeatedly(&generate_name/0) |> Enum.take_while(&exists?/1)
There are a hundred little variations on that you can do, combining various stream generators like repeatedly/1, unfold/1 and so forth with Enum.take* variants.
If those patterns aren’t a good fit, manual recursion is always a simple function a way.
2
sribe
Well if you want to limit the depth, you can always pass along a depth counter. But you probably won’t want to limit depth–other than to make sure that the recursive call is the last thing your function does, so that tail call optimization can limit the actual stack depth to 1.
3
silverdr
In a typical case I need one name, which is not yet taken…
… and I want to limit the number of checks so that if I tried - say - sixteen times and still don’t get a valid, non-yet-existing one, I can stop and notify that something’s probably wrong somewhere (namespace exhausted, misconfiguration, generator bug, etc.), instead of trying “forever”.
0
benwilson512
Author of Craft GraphQL APIs in Elixir with Absinthe
@silverdr OK sure, here’s a non manual loop version:
Stream.repeatedly(&generate_name/0) |> Stream.take(16) |> Enum.find(¬_taken?/1)
This will return the first generated name that isn’t taken, OR quit after 16 tries. It will only generate as many names as are needed. Enumerable works great here too. Of course, you can always use manual recursion.
4
silverdr
Huh, that’s all so different from what I am well used to that after many years of successfully doing it for a living (using too many languages/stacks to list) I feel like I am learning programming from scratch again 
That’s both refreshingly challenging and intimidating at the same time. For example looking at the line, I wouldn’t guess that it will generate “only as many as needed”. Thanks.
1
lucaong
That’s the beauty of lazy streams 
the original stream is actually infinite, but it only gets realized in a finite number of elements due to Stream.take and Enum.find.
2