Nested function: Difference between revisions

{{task}}

 

In many languages, functions can be nested, resulting in outer functions and inner functions. The inner function can access variables from the outer function. In most languages, the inner function can also modify variables in the outer function.

 

 

Write a program consisting of two nested functions that prints the following text.

 

The inner function (called <tt>MakeItem</tt> or equivalent) is responsible for creating a list item. It accesses the separator from the outer function and modifies the counter.

 

 

:* [[wp:Nested function|Nested function]]

 

 

=={{header|Ada}}==

 

procedure Nested_Functions is -- 'Nested_Functions' is the name of 'main'

Ada.Text_IO.Put_Line(Item);

end loop;

{{out}}

<pre>$ ./nested_functions

2. Second

3. Third

</pre>

 

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

BEGIN

INT counter := 0;

 

print( ( make list( ". " ) ) )

 

=={{header|ALGOL W}}==

Algol W strings are fixed length which makes this slightly more complicated than the Algol 68 solution.

string(30) procedure makeList ( string(2) value separator ) ;

begin

end; % makeList %

write( makeList( ". " ) )

 

=={{header|AppleScript}}==

 

-- makeList :: String -> String

end makeList

 

on run

 

 

 

-- map :: (a -> b) -> [a] -> [b]

on map(f, xs)

tell mReturn(f)

set lng to length of xs

return lst

end tell

{{Out}}

<pre>1. first

Note, however, that mutation creates redundant complexity and loss of referential transparency. Functions which modify values outside their own scope are rarely, if ever, necessary, and always best avoided. Simpler and sounder here to derive the incrementing index either by zipping the input list with a range of integers, or by inheriting it from the higher order map function:

 

on makeList(separator)

map(makeItem, ["first", "second", "third"]) as string

 

=={{header|ATS}}==

(* ****** ****** *)

//

 

(* ****** ****** *)

 

 

=={{header|C}}==

 

'''IMPORTANT''' This implementation will only work with GCC. Go through the link above for details.

#include<stdlib.h>

#include<stdio.h>

return 0;

}

Output:

<pre>

</pre>

 

{

int counter = 1;

}

 

'''Update'''<br/>

As of C#7, we can nest actual methods inside other methods instead of creating delegate instances. They can even be declared after the return statement.

{

int counter = 1;

//using string interpolation

string MakeItem(string item) => $"{counter++}{separator}{item}\n";

 

=={{header|Clojure}}==

 

(let [x (atom 0)]

(letfn [(make-item [item] (swap! x inc) (println (format "%s%s%s" @x separator item)))]

(make-item "third"))))

 

 

{{out}}

=={{header|Common Lisp}}==

 

(let ((counter 0))

(flet ((make-item (item)

(make-item "third")))))

 

 

''PS: A function named make-list is already defined in Common Lisp, see [http://www.lispworks.com/documentation/HyperSpec/Body/f_mk_lis.htm#make-list specification].''

 

=={{header|D}}==

 

int counter = 1;

 

import std.stdio : writeln;

writeln(makeList(". "));

 

=={{header|Delphi}}==

''See [[#Pascal|Pascal]]''

 

=={{header|Elena}}==

MakeList(separator)

var counter := 1;

^ makeItem("first") + makeItem("second") + makeItem("third")

{

console.printLine(MakeList(". "))

{{out}}

<pre>

=={{header|Elixir}}==

Elixir data are immutable. Anonymous functions are closures and as such they can access variables that are in scope when the function is defined. Keep in mind a variable assigned inside a function does not affect its surrounding environment:

def makeList(separator) do

counter = 1

end

 

 

{{out}}

<pre>

If we really wanted, we could also define a named word inside <code>make-list</code> at run time, using words such as <code>define</code> in the <code>words</code> vocabulary.

 

IN: rosetta-code.nested-functions

 

;

 

=={{header|Fortran}}==

===Arithmetic statement functions===

REAL X

DIST(U,V,W) = X*SQRT(U**2 + V**2 + W**2) !The contained function.

T = EXP(X)

F = T + DIST(T,SIN(X),ATAN(X) + 7) !Invoked...

This (deranged) function contains within it the definition of function DIST (which must be achieved in a single arithmetic statement), and which has access to all the variables of its containing function as well as its own parameters. The sequence <code>DIST(U,V,W) = ''etc.''</code> would normally be interpreted as an assignment of a value to an element of an array called DIST, but, no such array has been declared so this must therefore be the definition of an arithmetic statement function. Such functions are defined following any declarations of variables, and precede the normal executable statements such as <code>T = EXP(X)</code>. Since they are for arithmetic they cannot be used for character manipulations, and the CHARACTER variable only appeared with F77.

 

With the advent of F90 comes the CONTAINS statement, whereby within a function (or subroutine) but oddly, at its ''end'' (but before its END) appears the key word CONTAINS, after which further functions (and subroutines) may be defined in the established manner. These have access to all the variables defined in the containing routine, though if the contained routine declares a name used in the containing routine then that outside name becomes inaccessible.

 

CHARACTER*(*) TEXT !The supplied scratchpad.

INTEGER L !Its length.

CALL POOBAH(TEXT,L,". ")

WRITE (6,"(A)") TEXT(1:L)

 

Fortran doesn't offer a "list" construction as a built-in facility so it seemed easiest to prepare the list in a CHARACTER variable. These do not have a length attribute as in a string, the LEN function reports the size of the character variable not something such as the current length of a string varying from zero to the storage limit. So, the length of the in-use portion is tracked with the aid of an auxiliary variable, and one must decide on a sufficiently large scratchpad area to hold the anticipated result. And, since the items are of varying length, the length of the whole sequence is returned, not the number of items. Subroutine POOBAH could be instead a function, but, it would have to return a fixed-size result (as in say <code>CHARACTER*66 FUNCTION POOBAH(SEP)</code>) and can't return a length as well, unless via messing with a global variable such as in COMMON or via an additional parameter as with the L above.

 

===When storage is abundant===

CHARACTER*(*) TEXT(*) !The supplied scratchpad.

INTEGER N !Entry count.

CALL POOBAH(TEXT,N,". ")

WRITE (6,"(A)") (TEXT(I)(1:LEN_TRIM(TEXT(I))), I = 1,N)

The output statement could be <code>WRITE (6,"(A)") TEXT(1:N)</code> but this would write out the trailing spaces in each element. A TRIM intrinsic function may be available, but, leading spaces may be desired in the case that there are to be more than nine elements. If so, <code>FORMAT (I2,2A)</code> would be needed up to ninety-nine, or more generally, I0 format. Except that would not write out leading spaces and would spoil the neatness of a columnar layout. With file names, the lack of leading spaces (or zero digits) leads to the ideas explored in [[Natural_sorting|"Natural" sorting]]. One could define constants via the PARAMETER statement to document the linkage between the number of array elements and the correct FORMAT code, though this is messy because for NMAX elements the format code requires <Log10(NMAX) + 1> digits, and in such an attempt I've seen Log10(10) come out not as one but as 0·9999932 or somesuch, truncating to zero.

 

F95 introduced facilities whereby a string-style compound variable with both content and current length could be defined and manipulated, and when assigned to it would be reallocated storage so as to have exactly the size to hold the result. Later fortran standardised such a scheme. Similarly, one could define a data aggregate containing a count <code>N</code> as well as the <code>TEXT</code> array and a function could return such a compound entity as its result. It may also be possible to arrange that array TEXT becomes "ragged", that is, TEXT(i) is not always 28 characters long, but only as much as is needed to store the actual item.

 

=={{header|Free Pascal}}==

// but the the task doesn’t specify what to return.

// Hence makeList and makeItem became procedures.

makeItem;

makeItem;

 

=={{header|Go}}==

 

import "fmt"

 

func main() {

fmt.Print(makeList(". "))

 

=={{header|Haskell}}==

 

import Data.STRef

 

 

main :: IO ()

 

=={{header|Io}}==

counter := 1

makeItem := method(item,

makeItem("first") .. makeItem("second") .. makeItem("third")

)

 

=={{header|J}}==

That said, emulating a single level of nesting is relatively trivial and does not reflect the complexities necessary for more elaborate (and more difficult to understand) cases:

 

sep_MakeList_=: x

cnt_MakeList_=: 0

cnt_MakeList_=: cnt_MakeList_+1

(":cnt_MakeList_),sep_MakeList_,y,LF

 

Example use:

 

1. first

2. second

3. third

 

=={{header|Java}}==

Since version 8, Java has limited support for nested functions. All variables from the outer function that are accessed by the inner function have to be _effectively final_. This means that the counter cannot be a simple <tt>int</tt> variable; the closest way to emulate it is the <tt>AtomicInteger</tt> class.

 

import java.util.function.Function;

 

System.out.println(makeList(". "));

}

 

=={{header|JavaScript}}==

 

var counter = 1;

 

}

 

 

=={{header|jq}}==

 

# input: {text: _, counter: _}

def makeItem(item):

;

 

With the above in a file, say program.jq, the invocation:

=={{header|Jsish}}==

From Javascript entry.

function makeList(separator) {

var counter = 1;

 

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

cnt = 1

 

end

 

 

=={{header|Kotlin}}==

 

fun makeList(sep: String): String {

fun main(args: Array<String>) {

print(makeList(". "))

 

{{out}}

3. third

</pre>

 

=={{header|Lua}}==

 

local counter = 0

local function makeItem(item)

end

{{out}}

<pre>1. first

In M2000 functions may have functions, modules, subs, but these are black boxes. We can define globals for temporary use. Subs can use anything from module/function where we call them. First example use Subs inside a module, when call Make_list two local variables, Separator$ and Counter allocated in same space as module's. So when we call Make_item() these variables are visible. At the exit of sub Make_list local variables destroyed. In second example Letter$ pop a string from stack of values (or an error raised if no string found).

 

Module Checkit {

Make_List(". ")

 

Make_List1 ". "

 

=={{header|Maple}}==

makelist:=proc()

local makeitem,i;

end proc;

 

 

{counter=0, makeItem},

makeItem[item_String]:=ToString[++counter]<>sep<>item;

makeItem /@ {"first", "second", "third"}

]

 

=={{header|min}}==

{{works with|min|0.19.3}}

Note the <code>@</code> sigil is the key to altering <code>counter</code> in the outer scope.

:separator

1 :counter

) :make-list

 

 

=={{header|MiniScript}}==

Subfunctions can directly read variables in the enclosing scope, but to assign to those variables, they must explicitly use the ''outer'' specifier (added in MiniScript version 1.5). This is similar to how global variables are accessed via ''globals''.

counter = 0

makeItem = function(item)

end function

Output:

<pre>["1. first", "2. second", "3. third"]</pre>

=={{header|Nanoquery}}==

{{trans|Python}}

counter = 1

end

 

 

=={{header|Nim}}==

var counter = 1

result = $counter & separator & item & "\n"

inc counter

makeItem("first") & makeItem("second") & makeItem("third")

 

{{out}}

<pre>

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

 

__block int counter = 1;

NSLog(@"%@", makeList(@". "));

return 0;

 

=={{header|OCaml}}==

 

let counter = ref 1 in

 

 

let () =

Interestingly, on my computer it prints the numbers in reverse order, probably because the order of evaluation of arguments (and thus order of access of the counter) is undetermined:

{{out}}

=={{header|Perl}}==

 

my $separator = shift;

my $counter = 1;

}

 

 

=={{header|Phix}}==

end function

sequence res = {}

for i=1 to 3 do

end for

return res

end function

{{out}}

<pre>

{"1. first","2. second","3. third"}

</pre>

 

=={{header|PHP}}==

{{works with|PHP|5.3+}}

function makeList($separator) {

$counter = 1;

 

echo makeList(". ");

 

=={{header|PicoLisp}}==

(let (Cnt 0 makeItem '((Str) (prinl (inc 'Cnt) Sep Str)))

(makeItem "first")

(makeItem "third") ) )

 

 

=={{header|Python}}==

{{works with|Python|3+}}

counter = 1

 

return makeItem("first") + makeItem("second") + makeItem("third")

 

 

=={{header|Racket}}==

See also [[#Scheme]]; this demonstrates <code>map</code> a higher order function and <code>begin0</code> a form which saves us having to explicitly remember the result.

 

 

(define (make-list separator)

(apply string-append (map make-item '(first second third))))

 

{{out}}

<pre>1. first

This REXX version is modeled after the '''FreeBASIC''' example &nbsp; (and it has the

same limitations).

/*──────────────────────────────────────────────────────────────────────────────────────*/

return

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

1. first

 

=={{header|Ring}}==

# Project : Nested function

 

makeitem(sep, counter, a[counter])

end

Output:

<pre>

3. third

</pre>

 

=={{header|Ruby}}==

 

counter = 1

 

end

 

 

=={{header|Rust}}==

let mut counter = 0;

let mut make_item = |label| {

fn main() {

println!("{}", make_list(". "))

 

{{out}}

 

=={{header|Scala}}==

def main(args: Array[String]) {

val sep: String=". "

go("third")

}

 

{{out}}

=={{header|Scheme}}==

 

(define counter 1)

(string-append (make-item "first") (make-item "second") (make-item "third")))

 

 

=={{header|Seed7}}==

 

const func string: makeList (in string: separator) is func

begin

write(makeList(". "));

 

{{out}}

 

=={{header|Sidef}}==

 

var count = 1

}

 

{{out}}

<pre>

 

=={{header|Simula}}==

CLASS HEAD IS THE LIST ITSELF

CLASS LINK IS THE ELEMENT OF A LIST

 

END.

{{out}}

<pre>

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

 

let

val counter = ref 1;

end;

 

 

=={{header|SuperCollider}}==

f = { |separator|

var count = 0;

 

f.(".")

 

=={{header|Swift}}==

 

var counter = 1

}

 

 

=={{header|Tcl}}==

The code below satisfies the specification (inspired by the Swift example). The inner function MakeItem (which gains read/write access to its caller's variables via upvar) is defined, called, and then discarded by renaming to {}. suchenwi

 

proc MakeList separator {

}

puts [MakeList ". "]

 

=={{header|zkl}}==

zkl functions don't have direct access to another functions scope, they are not nested. If a function is defined in another function, the compiler moves it out and hands you a reference to the function. So, you are unable to modify variables in the enclosing scope unless you are given a container which can be modified. Partial application can be used to bind [copies] of scope information to a function, that information is fixed at the point of application and becomes strictly local to the binding function (ie changes do not propagate). A Ref[erence] is a container that holds an object so it can be modified by other entities.

counter:=Ref(1); // a container holding a one. A reference.

// 'wrap is partial application, in this case binding counter and separator

}

{{out}}

<pre>