I think tail call is very common. Consider following examples: def perform (input): # a "action" data = prepare(input) process(data) # tail call def result (input): # a "function" properly speaking data = prepare(input) return process(data) # tail call def case1 (input): if cond(input): <deal with common case in place> return deal_with_special_case() # tail call def case2 (input): if cond(input): <deal with special case in place> return deal_with_common_case() # tail call def perform_cases (input): if cond1(input): case1(input) # tail call elif cond2(input): case2(input) # tail call elif cond3(input): case3(input) # tail call def result_cases (input): if cond1(input): return case1(input) # tail call elif cond2(input): return case2(input) # tail call elif cond3(input): return case3(input) # tail call There are probably many more typical *schemas* of common tail call use cases. It is in any case very frequent, of pretty various usage, and not specific to functional or functional-like programming. Instead, we all use tail calls constantly, without even thinking at it, just like we constantly make prose ;-). [1] My point of view is not that tail call is a special (maybe very minoritary) kind of call, but that there are 2 kinds of calls maybe of equal importance: * delegation: another proc is passed the responsability of performing a task, or achieving the rest of it (tail call) * assistance: another proc is used to assist in a main task, still controlled and assumed by the main proc (sub call) I guess there are 2 main situations of delegation: / tail calls * the main proc sorts out cases and delegates in some or all cases * the main proc prepares the task and a delegate achieves it which may be mixed. (I may miss some, for sure.) "return from" may well do the job, but entertains imo wrong views about tail calls. Maybe "pass" would do the job better. When a delegate f performs an action (action, examples 'perform' & 'perform_cases' & 'case*' above), it can be interpreted as "pass the responsability of the task to f", or just "pass by f". When a delegate f computes a result (function, examples 'result' & 'result_cases' above) it can interpreted as "pass f's result back to the caller". (There is a similar ambiguity with "return", actually also matching semantic ambiguity.) denis [1] Allusion to https://en.wikipedia.org/wiki/Le_Bourgeois_gentilhomme