Is there a generic way to refer to the current function in recursion?

Question

In writing recursive functions (functional style), I often need to refer to the current function (depending on the context). e.g.

f 0  = 0
f (S n) = f n + 2

Are there any functional languages that allow using a generic name such as this_function or self to be used instead of the specific function name f?

So, hypothetically, the above would be rewritten as

f 0  = 0
f (S n) = self n + 2

It seems to make the spot of recursion easier to identify and the intention clearer. Also, it seems to allow one to write recursive anonymous functions, e.g. a function to double a number in pseudo-code:

\n r -> if n > 0 then self (n - 1) (r + 2) else r

Does such facility exist or is it possible?

Answer 1

APL

A few APL dialects support the glyph ∇ inside a dfn (which is pretty much a lambda) which refers to the dfn itself. See Dyalog documentation on recursion.

(I guess it depends if you consider APL a functional language or not, tbf it doesn't have a lot of features standard FP languages are supposed to have)

Answer 2

Forth

Recursion in Forth actually requires a construct like this, as a word is not visible inside its own definition. In order to recurse, you need to use the recurse word, like so:

: factorial ( n -- n! )
    dup 0> if
        dup 1- recurse *
    else
        drop 1
    endif
;

Answer 3

In Perl — which is not primarily a functional language, but does support functional programming styles — the keyword __SUB__ is a reference to the current subroutine; your last example could be written as

sub { my ($n, $r) = @_; $n > 0 ? __SUB__->($n-1, $r+2) : $r }

Wikipedia refers to this as anonymous recursion, and in addition to Perl and APL, it also mentions equivalent features in JavaScript and R.

Answer 4

Mathematica, a definition of the factorial function:

If[#1 == 1, 1, #1 #0[#1 - 1]]&

(The ampersand indicates a definition of an anonymous function; #0 is the anonymous function itself, and #1 is the first argument to that function.)

Answer 5

In JavaScript, arguments.callee could be used, but it is now deprecated and invalid in strict mode.

function f(n) { return n === 0 ? 0 : arguments.callee(n-1) + 2; }

Answer 6

In R we have Recall. From the docs we see (calling ?Recall):

Recall is used as a placeholder for the name of the function in which it is called. It allows the definition of recursive functions which still work after being renamed, see example below.

## A trivial (but inefficient!) example:
fib <- function(n)
   if(n<=2) { if(n>=0) 1 else 0 } else Recall(n-1) + Recall(n-2)
fibonacci <- fib; rm(fib)
## renaming wouldn't work without Recall
fibonacci(10) # 55

Answer 7

C++

Since C++23 you can add an explicit object parameter to member functions and lambdas. You still have to give the parameter a name, but you would typically use self for that argument:

auto factorial = [](this auto self, int n) -> int {
    return n > 1 ? n * self(n - 1) : 1;
}