Anonymous recursion: Difference between revisions

;Task:

If possible, demonstrate this by writing the recursive version of the fibonacci function   (see [[Fibonacci sequence]])   which checks for a negative argument before doing the actual recursion.

<br><br>

 

=={{header|11l}}==

{{trans|C++}}

F f(Int n) -> Int

I n < 2

 

Better would be to use type Natural instead of Integer, which lets Ada do the magic of checking the valid range.

function Actual_Fib (N: in Integer) return Integer is

begin

=={{header|ALGOL 68}}==

{{Trans|Ada}}

IF x < 0

THEN

though they are not quite first-class objects (you can't have an array of functions for example).

 

⍵<0:⎕SIGNAL 11 ⍝ DOMAIN ERROR if argument < 0

{ ⍝ Inner (anonymous) function

 

=={{header|AppleScript}}==

-- For the sake of the task, a needlessly anonymous local script object containing a needlessly recursive handler.

-- The script could easily (and ideally should) be assigned to a local variable.

Or, as the recursion of an anonymous declarative function, enabled by the Y combinator:

 

on run

=={{header|Arturo}}==

{{trans|Nim}}

; Using scoped function fibI inside fib

fibI: function [n][

 

=={{header|AutoHotkey}}==

nold1 := 1

nold2 := 0

 

=={{header|AutoIt}}==

ConsoleWrite(Fibonacci(10) & @CRLF) ; ## USAGE EXAMPLE

ConsoleWrite(Fibonacci(20) & @CRLF) ; ## USAGE EXAMPLE

=={{header|Axiom}}==

Using the Aldor compiler in Axiom/Fricas:

Z ==> Integer;

fib(x:Z):Z == {

f(x,1,1);

}</syntaxhighlight>The old Axiom compiler has scope issues with calling a local function recursively. One solution is to use the Reference (pointer) domain and initialise the local function with a dummy value:

Z ==> Integer

TestPackage : with

f()(x,1,1)</syntaxhighlight>

 

 

DEF FN fib(x) = FIB(x)

</syntaxhighlight>

 

{{trans|AutoIt}}

print Fibonacci(30)

print Fibonacci(-10)

55</pre>

 

 

{{works with|BBC BASIC for Windows}}

This works by finding a pointer to the 'anonymous' function and calling it indirectly:

END

55

</pre>

 

=={{header|Bracmat}}==

===lambda 'light'===

The first solution uses macro substitution. In an expression headed by an apostrophe operator with an empty lhs all subexpressions headed by a dollar operator with empty lhs are replaced by the values that the rhs are bound to, without otherwise evaluating the expression. Example: if <code>(x=7) & (y=4)</code> then <code>'($x+3+$y)</code> becomes <code>=7+3+4</code>. Notice that the solution below utilises no other names than <code>arg</code>, the keyword that always denotes a function's argument. The test for negative or non-numeric arguments is outside the recursive part. The function fails if given negative input.

=

. !arg:#:~<0

===pure lambda calculus===

(See http://en.wikipedia.org/wiki/Lambda_calculus). The following solution works almost the same way as the previous solution, but uses lambda calculus

' ( x

. $x:#:~<0

 

The following code calls an anonymous recursive Fibonacci function on each number of the range 0-9.

(𝕩<2)◶⟨+´𝕊¨,𝕏⟩𝕩-1‿2

}¨↕10</syntaxhighlight>

 

[https://mlochbaum.github.io/BQN/try.html#code=ewogICjwnZWpPDIp4pe24p+oK8K08J2VisKoLPCdlY/in6nwnZWpLTHigL8yCn3CqOKGlTEw Try It!]

 

Recursion can also be performed using an internal name defined by a header such as <code>Fact:</code> or <code>Fact 𝕩:</code>. This header is visible inside the block but not outside of it, so from the outside the function is anonymous. The named form allows the outer function to be called within nested blocks, while <code>𝕊</code> can only refer to the immediately containing one.

(𝕩<2)◶⟨+´Fact¨,𝕏⟩𝕩-1‿2

}¨↕10</syntaxhighlight>

=={{header|C}}==

Using scoped function fib_i inside fib, with GCC (required version 3.2 or higher):

 

long fib(long x)

 

Recursive functions can be defined within [https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html statement expressions]:

#include <stdio.h>

int main(){

=={{header|C sharp|C#}}==

The inner recursive function (delegate/lambda) has to be named.

static int Fib(int n)

{

=={{header|C++}}==

In C++ (as of the 2003 version of the standard, possibly earlier), we can declare class within a function scope. By giving that class a public static member function, we can create a function whose symbol name is only known to the function in which the class was derived.

{

if(n < 0)

}</syntaxhighlight>

{{works with|C++11}}

using namespace std;

 

Using a local function object that calls itself using <code>this</code>:

 

{

if(n < 0)

=={{header|Clio}}==

Simple anonymous recursion to print from 9 to 0.

if n:

n - 1 -> print -> recall</syntaxhighlight>

=={{header|Clojure}}==

The JVM as of now has no Tail call optimization so the default way of looping in Clojure uses anonymous recursion so not to be confusing.

(defn fib [n]

(when (neg? n)

 

=={{header|CoffeeScript}}==

# function call itself.

fibonacci = (n) ->

This version uses the anaphoric <code>lambda</code> from [http://dunsmor.com/lisp/onlisp/onlisp_18.html Paul Graham's On Lisp].

 

`(labels ((self ,parms ,@body))

#'self))</syntaxhighlight>

The Fibonacci function can then be defined as

 

(assert (>= n 0) nil "'~a' is a negative number" n)

(funcall

This puts a function in a local label. The function is not anonymous, but not only is it local, so that its name does not pollute the global namespace, but the name can be chosen to be identical to that of the surrounding function, so it is not a newly invented name

 

"Fibonacci sequence function."

(if (< number 0)

 

Here is <code>fib</code> rewritten to use RECURSIVE:

"Fibonacci sequence function."

(if (< number 0)

(recurse (- n 1) b (+ a b))))))</syntaxhighlight>

Implementation of RECURSIVE:

(let ((hidden-name (gensym "RECURSIVE-")))

`(macrolet ((recurse (&rest args) `(,',hidden-name ,@args)))

===Using the Y combinator===

 

(symbol-function '!!) (symbol-function 'apply))

 

 

=={{header|D}}==

assert(arg >= 0);

 

===With Anonymous Class===

In this version anonymous class is created, and by using opCall member function, the anonymous class object can take arguments and act like an anonymous function. The recursion is done by calling opCall inside itself.

 

int fib(in int n) pure nothrow {

This puts a function in a local method binding. The function is not anonymous, but the name fib1 is local and never pollutes the outside namespace.

 

define function fib (n)

when (n < 0)

=={{header|Déjà Vu}}==

===With Y combinator===

labda y:

labda:

!print fibo j</syntaxhighlight>

===With <code>recurse</code>===

n 0 1

labda times back-2 back-1:

 

=={{header|Delphi}}==

program AnonymousRecursion;

 

=={{header|EchoLisp}}==

A '''named let''' provides a local lambda via a label.

(define (fib n)

(let _fib ((a 1) (b 1) (n n))

=={{header|Ela}}==

Using fix-point combinator:

| else = fix (\f n -> if n < 2 then n else f (n - 1) + f (n - 2)) n</syntaxhighlight>

Function 'fix' is defined in standard Prelude as follows:

 

=={{header|Elena}}==

 

fib(n)

{

}

 

public program()

{

}</syntaxhighlight>

{{out}}

=={{header|Elixir}}==

With Y-Combinator:

fib = fn f -> (

fn x -> if x == 0, do: 0, else: (if x == 1, do: 1, else: f.(x - 1) + f.(x - 2)) end

{{out}}

102334155

 

=={{header|Erlang}}==

Two solutions. First fib that use the module to hide its helper. The helper also is called fib so there is no naming problem. Then fib_internal which has the helper function inside itself.

 

-module( anonymous_recursion ).

-export( [fib/1, fib_internal/1] ).

 

The function 'fib2' is only visible inside the 'fib' function.

| n when n < 0 -> None

| n -> let rec fib2 = function

in Some (fib2 n)</syntaxhighlight>

'''Using a fixed point combinator:'''

 

let fib = function

{{out}}

Both functions have the same output.

[null; Some 1; Some 1; Some 2; Some 3; Some 5; Some 8]</syntaxhighlight>

 

 

To achieve anonymous recursion, this solution has a recursive quotation.

IN: rosettacode.fibonacci.ar

 

=={{header|Falcon}}==

Falcon allows a function to refer to itself by use of the fself keyword which is always set to the currently executing function.

if x < 0

raise ParamError(description|"Negative argument invalid", extra|"Fibbonacci sequence is undefined for negative numbers")

 

=={{header|FBSL}}==

 

FUNCTION Fibonacci(n)

Recursion is always anonymous in Forth, allowing it to be used in anonymous functions. However, definitions can't be defined during a definition (there are no 'local functions'), and the data stack can't be portably used to get data into a definition being defined.

{{works with|SwiftForth}} - and any Forth in which colon-sys consumes zero cells on the data stack.

dup 2 < ?exit

1- dup recurse swap 1- recurse + ; ( xt )

[ ( xt from the :NONAME above ) compile, ] ;</syntaxhighlight>

Portability is achieved with a once-off variable (or any temporary-use space with a constant address - i.e., not PAD):

variable pocket pocket !

: fib ( +n -- n' )

[ pocket @ compile, ] ;</syntaxhighlight>

Currently, most Forths have started to support embedded definitions (shown here for iForth):

dup 0< abort" Negative numbers don't exist"

[: dup 2 < ?exit 1- dup MYSELF swap 1- MYSELF + ;] execute . ;</syntaxhighlight>

=={{header|Fortran}}==

Since a hidden named function instead of an anonymous one seems to be ok with implementors, here is the Fortran version:

integer, intent(in) :: n

if (n < 0 ) then

 

However, for compatibility with old QB code, gosub can be used if one specifies the 'fblite', 'qb' or 'deprecated dialects:

 

#Lang "fblite"

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

Y combinator solution. Go has no special support for anonymous recursion.

 

import "fmt"

fib 40 = 102334155

fib undefined for negative numbers

</pre>

 

=={{header|Groovy}}==

Groovy does not explicitly support anonymous recursion. This solution is a kludgy trick that takes advantage of the "owner" scoping variable (reserved word) for closures.

assert it > -1

{i -> i < 2 ? i : {j -> owner.call(j)}(i-1) + {k -> owner.call(k)}(i-2)}(it)

}</syntaxhighlight>

Test:

println fib0to20

 

 

We're defining a function 'real' which is only available from within the fib function.

fib n

| n < 0 = Nothing

 

This uses the 'fix' function to find the fixed point of the anonymous function.

 

fib :: Integer -> Maybe Integer

{{out}}

Both functions provide the same output when run in GHCI.

[Nothing,Nothing,Nothing,Nothing,Just 1,Just 1,Just 2,Just 3,Just 5,Just 8,Just 13,Just 21,Just 34,Just 55,Just 89]</syntaxhighlight>

 

Or, without imports (inlining an anonymous fix)

 

fib n

| n < 0 = Nothing

 

This example does accomplish the goals of hiding the procedure inside ''fib'' so that the type and value checking is outside the recursion. It also does not require an identifier to reference the inner procedure; but, it requires a local variable to remember our return point. Also, each recursion will result in the current co-expression being refreshed, essentially copied, placing a heavy demand on co-expression resources.

every write("fib(",a := numeric(!A),")=",fib(a))

end

 

For reference, here is the non-cached version:

local source, i

if type(n) == "integer" & n >= 0 then

=={{header|Io}}==

The most natural way to solve this task is to use a nested function whose scope is limited to the helper function.

if(x < 0, Exception raise("Negative argument not allowed!"))

fib2 := method(n,

fib2(x floor)

)</syntaxhighlight>

 

=={{header|J}}==

Copied directly from the [[Fibonacci_sequence#J|fibonacci sequence]] task, which in turn copied from one of several implementations in an [[j:Essays/Fibonacci_Sequence|essay]] on the J Wiki:

Note that this is an identity function for arguments less than 1 (and 1 (and 5)).

 

'''Examples:'''

144

fibN i.31

Note also http://www.jsoftware.com/pipermail/general/2003-August/015571.html which points out that the form

 

 

Of course, that won't work here, because we are adding two recursively obtained results where tail recursion requires that the recursive result is the final result.

Creates an anonymous inner class to do the dirty work. While it does keep the recursive function out of the namespace of the class, it does seem to violate the spirit of the task in that the function is still named.

 

if (n < 0)

throw new IllegalArgumentException("n can not be a negative number");

Note that the fib method below is practically the same as that of the version above, with less fibInner.

 

 

@FunctionalInterface

 

=={{header|JavaScript}}==

if (n < 0) { throw "Argument cannot be negative"; }

 

return (function(n) {

})(n);

}</syntaxhighlight>

Note that <code>arguments.callee</code> will not be available in ES5 Strict mode. Instead, you are expected to "name" function (the name is only visible inside function however).

if (n < 0) { throw "Argument cannot be negative"; }

 

return (function fib(n) {

})(n);

}</syntaxhighlight>

=={{header|Joy}}==

This definition is taken from "Recursion Theory and Joy" by Manfred von Thun.

 

=={{header|jq}}==

The "recurse" filter supports a type of anonymous recursion, e.g. to generate a stream of integers starting at 0:

 

Also, as is the case for example with Julia, jq allows you to define an inner/nested function (in the follow example, <code>aux</code>) that is only defined within the scope of the surrounding function (here <code>fib</code>). It is thus invisible outside the function:

def aux: if . == 0 then 0

elif . == 1 then 1

=={{header|Julia}}==

Julia allows you to define an inner/nested function (here, <code>aux</code>) that is only defined within the surrounding function <code>fib</code> scope.

if n < 0

throw(ArgumentError("negative arguments not allowed"))

 

=={{header|K}}==

'''Examples:'''

0 1 1 2 3 5 8 13 21 34

fib -1

 

=={{header|Klingphix}}==

 

 

=={{header|Klong}}==

fib::{:[x<0;"error: negative":|x<2;x;.f(x-1)+.f(x-2)]}

</syntaxhighlight>

=={{header|Kotlin}}==

{{trans|Dylan}}

require(n >= 0)

}

 

 

=={{header|Lambdatalk}}==

1) defining a quasi-recursive function combined with a simple Ω-combinator:

{def fibo {lambda {:n}

8}

-> 34

</syntaxhighlight>

 

=={{header|Lingo}}==

Lingo does not support anonymous functions. But what comes close: you can create and instantiate an "anonymous class":

if n<0 then return _player.alert("negative arguments not allowed")

 

end</syntaxhighlight>

 

-- 55</syntaxhighlight>

 

=={{header|LOLCODE}}==

{{trans|C}}

 

HOW IZ I fib YR x

=={{header|Lua}}==

Using a [[Y combinator]].

 

return Y(function(fibs)

end)</syntaxhighlight>

using a metatable (also achieves memoization)

self[n] = self[n-1] + self[n-2]

return self[n]

We can use a function in string. We can named it so the error say about "Fibonacci"

To exclude first check for negative we have to declare a function in anonymous function, which may have a name (a local name)

A$={{ Module "Fibonacci" : Read X :If X<0 then {Error {X<0}} Else Fib=Lambda (x)->if(x>1->fib(x-1)+fib(x-2), x) : =fib(x)}}

Try Ok {

For recursion we can use Lambda() or Lambda$() (for functions which return string) and not name of function so we can use it in a referenced function. Here in k() if we have the fib() we get an error, but with lambda(), interpreter use current function's name.

 

Function fib(x) {

If x<0 then Error "argument outside of range"

Using lambda function

 

fib=lambda -> {

fib1=lambda (x)->If(x>1->lambda(x-1)+lambda(x-2), x)

 

 

Class Something {

\\ this class is a global function

=={{header|Maple}}==

In Maple, the keyword thisproc refers to the currently executing procedure (closure), which need not be named. The following defines a procedure Fib, which uses a recursive, anonymous (unnamed) procedure to implement the Fibonacci sequence. For better efficiency, we use Maple's facility for automatic memoisation ("option remember").

Fib := proc( n :: nonnegint )

proc( k )

</syntaxhighlight>

For example:

> seq( Fib( i ), i = 0 .. 10 );

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55

=={{header|Mathematica}} / {{header|Wolfram Language}}==

An anonymous reference to a function from within itself is named #0, arguments to that function are named #1,#2..#n, n being the position of the argument. The first argument may also be referenced as a # without a following number, the list of all arguments is referenced with ##. Anonymous functions are also known as [http://reference.wolfram.com/mathematica/tutorial/PureFunctions.html pure functions] in Mathematica.

fib := If[check[#],Throw["Negative Argument"],If[#<=1,1,#0[#-2]+#0[#-1]]&[#]]&

fib /@ Range[0,10]

{1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89}</syntaxhighlight>

Making sure that the check is only performed once.

fib /@ Range[0,4]

0

* does not need a new name, can reuse the parent name

* a nested function can be defined in the place where it is needed

function v = fibonacci(n)

assert(n >= 0)

* inner function not expected to be called from anywhere else

* nesting maintains program flow in source code

using System.Console;

 

 

=={{header|Nim}}==

proc fib(x: int): int =

proc fibI(n: int): int =

=={{header|Objective-C}}==

This shows how a method (not regular function) can recursively call itself without explicitly putting its name in the code.

 

@interface AnonymousRecursion : NSObject { }

;With internal named recursive block:

{{works with|Mac OS X|10.6+}}

 

int fib(int n) {

 

When ARC is disabled, the above should be:

 

int fib(int n) {

 

We're defining a function 'real' which is only available from within the fib function.

let rec real = function

0 -> 1

 

This uses the 'fix' function to find the fixed point of the anonymous function.

 

let fib n =

=={{header|Ol}}==

This uses named let to create a local function (loop) that only exists inside of function fibonacci.

(define (fibonacci n)

(if (> 0 n)

=={{header|OxygenBasic}}==

An inner function keeps the name-space clean:

function fiboRatio() as double

function fibo( double i, j ) as double

=={{header|PARI/GP}}==

This version uses a Y combinator to get a self-reference.

my(F=(k,f)->if(k<2,k,f(k-1,f)+f(k-2,f)));

if(n<0,(-1)^(n+1),1)*F(abs(n),F)

{{works with|PARI/GP|2.8.1+}}

This version gets a self-reference from <code>self()</code>.

my(F=k->my(f=self());if(k<2,k,f(k-1)+f(k-2)));

if(n<0,(-1)^(n+1),1)*F(abs(n))

 

=={{header|Pascal}}==

program AnonymousRecursion;

 

{{trans|PicoLisp}}

<code>recur</code> isn't built into Perl, but it's easy to implement.

my $f = shift;

local *recurse = $f;

}</syntaxhighlight>

Although for this task, it would be fine to use a lexical variable (closure) to hold an anonymous sub reference, we can also just push it onto the args stack and use it from there:

my ($n) = @_;

die "negative arg $n" if $n < 0;

print(fib($_), " ") for (0 .. 10);</syntaxhighlight>

One can also use <code>caller</code> to get the name of the current subroutine as a string, then call the sub with that string. But this won't work if the current subroutine is anonymous: <code>caller</code> will just return <code>'__ANON__'</code> for the name of the subroutine. Thus, the below program must check the sign of the argument every call, failing the task. Note that under stricture, the line <code>no strict 'refs';</code> is needed to permit using a string as a subroutine.

my $n = shift;

$n < 0 and die 'Negative argument';

===Perl 5.16 and __SUB__===

Perl 5.16 introduced __SUB__ which refers to the current subroutine.

say sub {

my $n = shift;

===using classes===

With proof that the private fib_i() does not pollute the outer namespace.

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (no class yet)</span>

<span style="color: #008080;">class</span> <span style="color: #000000;">Fib</span>

Obviously the inner function does not have to and in fact is not allowed to have a name itself, but it needs to be stored in something with a name before it can be called,

and in being anonymous, in order to effect recursion it must be passed to itself, repeatedly and not really anonymous at all anymore.

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (no lambda yet)</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">erm</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>

In this solution, the function is always called using <code>call_user_func()</code> rather than using function call syntax directly. Inside the function, we get the function itself (without having to refer to the function by name) by relying on the fact that this function must have been passed as the first argument to <code>call_user_func()</code> one call up on the call stack. We can then use <code>debug_backtrace()</code> to get this out.

{{works with|PHP|5.3+}}

function fib($n) {

if ($n < 0)

;With internal named recursive function:

{{works with|PHP|5.3+}}

function fib($n) {

if ($n < 0)

;With a function object that can call itself using <code>$this</code>:

{{works with|PHP|5.3+}}

class fib_helper {

function __invoke($n) {

 

=={{header|PicoLisp}}==

(if (lt0 N)

(quit "Illegal argument" N) )

(+ (recurse (dec N)) (recurse (- N 2))) ) ) )</syntaxhighlight>

Explanation: The above uses the '[http://software-lab.de/doc/refR.html#recur recur]' / '[http://software-lab.de/doc/refR.html#recurse recurse]' function pair, which is defined as a standard language extensions as

(run (cdr recurse)) )</syntaxhighlight>

Note how 'recur' dynamically defines the function 'recurse' at runtime, by binding the rest of the expression (i.e. the body of the 'recur' statement) to the symbol 'recurse'.

{{libheader|initlib}}

Postscript can make use of the higher order combinators to provide recursion.

/pfact {

{1} {*} primrec}.

Works with SWI-Prolog and module <b>lambda</b>, written by <b>Ulrich Neumerkel</b> found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

The code is inspired from this page : http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/ISO-Hiord#Hiord (p 106). It uses the Y combinator.

 

fib(N, _F) :-

 

=={{header|Python}}==

>>> fib = lambda f: lambda n: None if n < 0 else (0 if n == 0 else (1 if n == 1 else f(n-1) + f(n-2)))

>>> [ Y(fib)(i) for i in range(-2, 10) ]

 

Same thing as the above, but modified so that the function is uncurried:

>>> Y = lambda f: (lambda x: x(x))(lambda y: partial(f, lambda *args: y(y)(*args)))

>>> fib = lambda f, n: None if n < 0 else (0 if n == 0 else (1 if n == 1 else f(n-1) + f(n-2)))

 

A different approach: the function always receives itself as the first argument, and when recursing, makes sure to pass the called function as the first argument also

>>> Y = lambda f: partial(f, f)

>>> fib = lambda f, n: None if n < 0 else (0 if n == 0 else (1 if n == 1 else f(f, n-1) + f(f, n-2)))

 

An interesting approach using introspection (from http://metapython.blogspot.com/2010/11/recursive-lambda-functions.html)

>>> from inspect import currentframe

>>> from types import FunctionType

Another way of implementing the "Y" function is given in this post: https://stackoverflow.com/questions/481692/can-a-lambda-function-call-itself-recursively-in-python. The main problem to solve is that the function "fib" can't call itself. Therefore, the function "Y" is used to help "fib" call itself.

 

>>> Y = lambda f: lambda n: f(f,n)

>>> fib = lambda f, n: None if n < 0 else (0 if n == 0 else (1 if n == 1 else f(f,n-1) + f(f,n-2))) #same as the first three implementations

 

All in one line:

>>> fib_func = (lambda f: lambda n: f(f,n))(lambda f, n: None if n < 0 else (0 if n == 0 else (1 if n == 1 else f(f,n-1) + f(f,n-2))))

>>> [ fib_func(i) for i in range(-2, 10) ]

{{works with|QBasic}}

{{trans|BASIC256}}

 

PRINT Fibonacci(20)

However, it can be done, for instance like this:

 

(define fib

N -> (let A (/. A N

=={{header|R}}==

R provides Recall() as a wrapper which finds the calling function, with limitations; Recall will not work if passed to another function as an argument.

(n >= 0) || stop("bad argument")

( function(n) if (n <= 1) 1 else Recall(n-1)+Recall(n-2) )(n)

In Racket, local helper function definitions inside of a function are only visible locally and do not pollute the module or global scope.

 

#lang racket

 

This calculates the slightly more complex Fibonacci funciton:

#lang racket

;; Natural -> Natural

Also with the help of first-class functions in Racket, anonymous recursion can be implemented using fixed-points operators:

 

#lang racket

;; We use Z combinator (applicative order fixed-point operator)

 

In addition to the methods in the [[Perl]] entry above, and the Y-combinator described in [[Y_combinator]], you may also refer to an anonymous block or function from the inside:

die "Naughty fib" if $n < 0;

return {

say fib(10);</syntaxhighlight>

However, using any of these methods is insane, when Raku provides a sort of inside-out combinator that lets you define lazy infinite constants, where the demand for a particular value is divorced from dependencies on more primitive values. This operator, known as the sequence operator, does in a sense provide anonymous recursion to a closure that refers to more primitive values.

say @fib[10];</syntaxhighlight>

Here the closure, <tt>*+*</tt>, is just a quick way to write a lambda, <tt>-> $a, $b { $a + $b }</tt>. The sequence operator implicitly maps the two arguments to the -2nd and -1st elements of the sequence. So the sequence operator certainly applies an anonymous lambda, but whether it's recursion or not depends on whether you view a sequence as iteration or as simply a convenient way of memoizing a recursion. Either view is justifiable.

=={{header|REBOL}}==

 

fib: func [n /f][ do f: func [m] [ either m < 2 [m][(f m - 1) + f m - 2]] n]

</syntaxhighlight>

to be OK with the implementers, here are the REXX versions.

===simplistic===

numeric digits 1e6 /*in case the user goes ka-razy with X.*/

parse arg x . /*obtain the optional argument from CL.*/

Since the above REXX version is &nbsp; ''very'' &nbsp; slow for larger numbers, the following version was added that incorporates memoization. &nbsp;

<br>It's many orders of magnitude faster for larger values.

numeric digits 1e6 /*in case the user goes ka-razy with X.*/

parse arg x . /*obtain the optional argument from CL.*/

 

=={{header|Ring}}==

# Project : Anonymous recursion

 

144

</pre>

 

=={{header|Ruby}}==

We can recurse a block of code, but we must provide the block with a reference to itself. The easiest solution is to use a local variable.

===Ruby with local variable===

raise RangeError, "fib of negative" if n < 0

(fib2 = proc { |m| m < 2 ? m : fib2[m - 1] + fib2[m - 2] })[n]

end</syntaxhighlight>

 

=> [:error, :error, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]</syntaxhighlight>

 

 

'''Caution!''' The recursive block has a difference from Ruby 1.8 to Ruby 1.9. Here is the same method, except changing the block parameter from 'm' to 'n', so that block 'n' and method 'n' have the same name.

raise RangeError, "fib of negative" if n < 0

(fib2 = proc { |n| n < 2 ? n : fib2[n - 1] + fib2[n - 2] })[n]

end</syntaxhighlight>

(-2..12).map { |i| fib i rescue :error }

=> [:error, :error, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]

Ruby 1.9 still shows the correct answer, but Ruby 1.8 shows the wrong answer. With Ruby 1.9, 'n' is still a local variable of the block. With Ruby 1.8, 'n' of the block closes on 'n' of the fib() method. All calls to the block share the 'n' of one call to the method. So <tt>fib2[n - 1]</tt> changes the value of 'n', and <tt>fib2[n - 2]</tt> uses the wrong value of 'n', thus the wrong answer.

===Ruby with Hash===

raise RangeError, "fib of negative" if n < 0

Hash.new { |fib2, m|

{{trans|PicoLisp}}

{{libheader|continuation}}

 

module Kernel

{{trans|JavaScript}}

{{libheader|continuation}}

 

module Kernel

 

=={{header|Rust}}==

// A function declared inside another function does not pollute the outer namespace.

fn actual_fib(n: i64) -> i64 {

=={{header|Scala}}==

Using a Y-combinator:

def fib(n: Int): Option[Int] =

=={{header|Scheme}}==

This uses named let to create a function (aux) that only exists inside of fibonacci:

(if (> 0 n)

"Error: argument must not be negative."

=={{header|Seed7}}==

Uses a local function to do the dirty work. The local function has a name, but it is not in the global namespace.

 

const func integer: fib (in integer: x) is func

=={{header|Sidef}}==

__FUNC__ refers to the current function.

return NaN if (n < 0)

 

__BLOCK__ refers to the current block.

 

return NaN if (n < 0)

 

a) Use a funny local name (in this case: "_").

Here the closure is defined as "_", and then evaluated (by sending it a <tt>value:</tt> message).

myMethodComputingFib:arg

|_|

<br>Here, a separate closure is defined (and evaluated with <tt>value</tt>), in which fib is defined and evaluated with the argument.

This is semantically equivalent to the named let solution of Scheme.

myMethodComputingFib2:arg

^ [

=={{header|Sparkling}}==

As a function expression:

return f(n, f);

}(10, function(n, f) {

 

When typed into the REPL:

= 89</syntaxhighlight>

 

=={{header|Standard ML}}==

ML does not have a built-in construct for anonymous recursion, but you can easily write your own fix-point combinator:

 

fun fib n =

 

Instead of using a fix-point, the more common approach is to locally define a recursive function and call it once:

let

fun fib 0 = 0

 

Another variation is possible. Instead, we could define the recursive "fib" at top-level, then shadow it with a non-recursive wrapper. To force the wrapper to be non-recursive, we use the "val" syntax instead of "fun":

| fib 1 = 1

| fib n = fib (n-1) + fib (n-2)

SuperCollider has a keyword "thisFunction", which refers to the current function context. The example below uses this for anonymous recursion. One may think that "thisFunction" would refer to the second branch of the if statement, but because if statements are inlined, the function is the outer one.

 

(

f = { |n|

;With internal named recursive closure:

{{works with|Swift|2.x}}

func f(n: Int) -> Int {

assert(n >= 0, "fib: no negative numbers")

print(fib(8))</syntaxhighlight>

{{works with|Swift|1.x}}

var f: (Int -> Int)!

f = { n in

 

;Using Y combinator:

let o : RecursiveFunc<F> -> F

}

=={{header|Tcl}}==

This solution uses Tcl 8.5's lambda terms, extracting the current term from the call stack using introspection (storing it in a local variable only for convenience, with that ''not'' in any way being the name of the lambda term; just what it is stored in, and only as a convenience that keeps the code shorter). The lambda terms are applied with the <code>apply</code> command.

# sanity checks

if {[incr n 0] < 0} {error "argument may not be negative"}

}</syntaxhighlight>

Demonstrating:

{{out}}}

<pre>144</pre>

The code above can be written without even using a local variable to hold the lambda term, though this is generally less idiomatic because the code ends up longer and clumsier:

if {[incr n 0] < 0} {error "argument may not be negative"}

apply {x {expr {

}</syntaxhighlight>

However, we can create a <code>recurse</code> function that makes this much more straight-forward:

proc tcl::mathfunc::recurse args {apply [lindex [info level -1] 1] {*}$args}

proc fib n {

{{trans|BASIC256}}

{{works with|QBasic}}

IF num < 0 THEN

PRINT "Invalid argument: ";

{{trans|Common_Lisp}}

 

(let ((hidden-name (gensym "RECURSIVE-")))

^(macrolet ((recurse (. args) ^(,',hidden-name ,*args)))

=={{header|UNIX Shell}}==

The shell does not have anonymous functions. Every function must have a name. However, one can create a subshell such that some function, which has a name in the subshell, is effectively anonymous to the parent shell.

if test 0 -gt "$1"; then

echo "fib: fib of negative" 1>&2

fi

}</syntaxhighlight>

> fib $i

> done

 

=={{header|Ursala}}==

 

fib =

'''Solution with anonymous class'''

 

···

http://rosettacode.org/wiki/Anonymous_recursion

 

=={{header|VBA}}==

Sub Main()

Debug.Print F(-10)

 

=={{header|Wart}}==

if (n >= 0)

(transform n :thru (afn (n)

 

=={{header|WDTE}}==

 

let fib n => switch n {

 

=={{header|Wren}}==

static compute(n) {

var fib

The address of the instructions after the function get put on the stack and then execution continues into the actual function.

When the recursion is complete, instead of returning to the location of the call it goes to the end of the loop.

; Calculates and prints Fibonacci numbers (Fn)

; Prints numbers 1 - 47 (largest 32bit Fn that fits)

This makes those nested functions invisible to the outside, thus preventing namespace pollution.

 

 

func Fib(X);

=={{header|Yabasic}}==

{{trans|AutoIt}}

print Fibonacci(10)

 

 

=={{header|zkl}}==

if (n<0) throw(Exception.ValueError);

fcn(n){

=={{header|ZX Spectrum Basic}}==

{{trans|AutoHotkey}}

20 LET t=0

30 GO SUB 60