Nested function

Nested function
You are encouraged to solve this task according to the task description, using any language you may know.

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.

Task

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

1. first
2. second
3. third

The outer function (called MakeList or equivalent) is responsible for creating the list as a whole and is given the separator ". " as argument. It also defines a counter variable to keep track of the item number. This demonstrates how the inner function can influence the variables in the outer function.

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

References

• Nested function

11l

Translation of: Python

<lang 11l>F makeList(separator)

  V counter = 1

  F makeItem(item)
     -V result = @counter‘’@separator‘’item"\n"
     @counter++
     R result

  R makeItem(‘first’)‘’makeItem(‘second’)‘’makeItem(‘third’)

print(makeList(‘. ’))</lang>

Output:

1. first
2. second
3. third

Ada

<lang Ada>with Ada.Text_IO;

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

  type List is array(Natural range <>) of String(1 .. 10);
  
  function Make_List(Separator: String) return List is
     Counter: Natural := 0;
     
     function Make_Item(Item_Name: String) return String is
     begin

Counter := Counter + 1; -- local in Make_List, global in Make_Item return(Natural'Image(Counter) & Separator & Item_Name);

     end Make_Item;
     
  begin
     return (Make_Item("First "), Make_Item("Second"), Make_Item("Third "));
  end Make_List;
  

begin -- iterate through the result of Make_List

  for Item of Make_List(". ") loop
     Ada.Text_IO.Put_Line(Item);
  end loop;

end Nested_Functions;</lang>

Output:

$ ./nested_functions 
 1. First 
 2. Second
 3. Third 

ALGOL 68

<lang algol68>PROC make list = ( STRING separator )STRING:

    BEGIN
       INT counter := 0;
       PROC make item = ( STRING item )STRING:
            BEGIN
               counter +:= 1;
               whole( counter, 0 ) + separator + item + REPR 10
            END; # make item #
       make item( "first" ) + make item( "second" ) + make item( "third" )
    END; # make list #

print( ( make list( ". " ) ) ) </lang>

ALGOL W

Algol W strings are fixed length which makes this slightly more complicated than the Algol 68 solution. <lang algolw>begin

   string(30) procedure makeList ( string(2) value separator ) ;
       begin
           string(30) listValue;
           integer counter;
           string(10) procedure makeItem ( string(6) value item
                                         ; integer   value length
                                         ) ;
               begin
                   string(10) listItem;
                   counter := counter + 1;
                   listItem( 0 // 1 ) := code( decode( "0" ) + counter );
                   listItem( 1 // 2 ) := separator;
                   listItem( 3 // 6 ) := item;
                   listItem( 3 + length // 1 ) := code( 10 );
                   listItem
               end; % makeItem %
               counter   := 0;
               listValue := makeItem( "first", 5 );
               listValue(  9 // 10 ) := makeItem( "second", 6 );
               listValue( 19 // 10 ) := makeItem( "third",  5 );
               listValue
        end; % makeList %
   write( makeList( ". " ) )

end.</lang>

AppleScript

<lang AppleScript>--------------------- NESTED FUNCTION --------------------

-- makeList :: String -> String on makeList(separator)

   set counter to 0
   
   -- makeItem :: String -> String
   script makeItem
       on |λ|(x)
           set counter to counter + 1
           
           (counter & separator & x & linefeed) as string
       end |λ|
   end script
   
   map(makeItem, ["first", "second", "third"]) as string

end makeList

---

TEST -------------------------

on run

   makeList(". ")
   

end run

---

GENERIC FUNCTIONS -------------------

-- mReturn :: First-class m => (a -> b) -> m (a -> b) on mReturn(f)

   -- 2nd class handler function lifted into 1st class script wrapper. 
   if script is class of f then
       f
   else
       script
           property |λ| : f
       end script
   end if

end mReturn

-- map :: (a -> b) -> [a] -> [b] on map(f, xs)

   -- The list obtained by applying f
   -- to each element of xs.
   tell mReturn(f)
       set lng to length of xs
       set lst to {}
       repeat with i from 1 to lng
           set end of lst to |λ|(item i of xs, i, xs)
       end repeat
       return lst
   end tell

end map</lang>

Output:

1. first
2. second
3. third

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:

<lang AppleScript>-- makeList :: String -> String on makeList(separator)

   -- makeItem :: String -> Int -> String
   script makeItem
       on |λ|(x, i)
           (i & separator & x & linefeed) as string
       end |λ|
   end script
   
   map(makeItem, ["first", "second", "third"]) as string

end makeList</lang>

Arturo

<lang rebol>makeList: function [separator][

   counter: 1

   makeItem: function [item] .export:[counter][
       result: ~"|counter||separator||item|"
       counter: counter+1
       return result
   ]

   @[
       makeItem "first"
       makeItem "second"
       makeItem "third"
   ]

]

print join.with:"\n" makeList ". "</lang>

Output:

1. first
2. second
3. third

ATS

<lang ATS> (* ****** ****** *) //

1. include

"share/atspre_staload.hats" // (* ****** ****** *)

fun MakeList (

 sep: string

) : void = let // var count: int = 0 // val count =

 $UNSAFE.cast{ref(int)}(addr@count)

// fun MakeItem (

 item: string

) : void = let

 val () = !count := !count+1

in

 println! (!count, sep, item)

end // end of [MakeItem] // in

 MakeItem"first"; MakeItem"second"; MakeItem"third"

end // end of [MakeList]

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

implement main0() = { val () = MakeList". " }

(* ****** ****** *) </lang>

BQN

<lang bqn>MakeList ← {

   nl←@+10 ⋄ s←𝕩 ⋄ i←0
   MakeItem ← {i+↩1 ⋄ (•Fmt i)∾s∾𝕩}
   (⊣∾nl∾⊢)´MakeItem¨"first"‿"second"‿"third"

}</lang>

Output:

   MakeList ". "
"1. first
2. second
3. third"

C

I honestly never thought this task could ever be done in C and then I was surprised, again. It turns out that nested functions although not a C standard are supported by GCC. I have used anonymous functions in Java and frankly, I don't see any practical benefit other than making code even harder to read. Then again, that's one of the strengths of C. For example, I still have no clue how come the sprintf line is working correctly. I expected the first line of the list to be '1. second', but no, C is C is C.

Not sure who "I" is; but the reason you don't understand the code near sprintf is it's wrong and works by accident. Use of the variable a second time while it's being preincremented has no behavior. Joshudson (talk) 21:33, 3 March 2020 (UTC)JH

---

IMPORTANT This implementation will only work with GCC. Go through the link above for details. <lang C>

1. include<stdlib.h>
2. include<stdio.h>

typedef struct{ char str[30]; }item;

item* makeList(char* separator){ int counter = 0,i; item* list = (item*)malloc(3*sizeof(item));

item makeItem(){ item holder;

char names[5][10] = {"first","second","third","fourth","fifth"};

sprintf(holder.str,"%d%s%s",++counter,separator,names[counter]);

return holder; }

for(i=0;i<3;i++) list[i] = makeItem();

return list; }

int main() { int i; item* list = makeList(". ");

for(i=0;i<3;i++) printf("\n%s",list[i].str);

return 0; } </lang> Output:

1. first
2. second
3. third

C#

<lang csharp>string MakeList(string separator) {

   int counter = 1;

   Func<string, string> makeItem = item => counter++ + separator + item + "\n";

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

}

Console.WriteLine(MakeList(". "));</lang> Update
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. <lang csharp>string MakeList2(string separator) {

   int counter = 1;

   return MakeItem("first") + MakeItem("second") + MakeItem("third");
   //using string interpolation
   string MakeItem(string item) => $"{counter++}{separator}{item}\n";

}</lang>

C++

Works with: C++11

<lang cpp>#include <iostream>

1. include <string>
2. include <vector>

std::vector<std::string> makeList(std::string separator) {

 auto counter = 0;
 auto makeItem = [&](std::string item) {
   return std::to_string(++counter) + separator + item;
 };
 return {makeItem("first"), makeItem("second"), makeItem("third")};

}

int main() {

 for (auto item : makeList(". "))
   std::cout << item << "\n";

}</lang>

Clojure

<lang clojure>(defn make-list [separator]

 (let [x (atom 0)]
   (letfn [(make-item [item] (swap! x inc) (println (format "%s%s%s" @x separator item)))]
     (make-item "first")
     (make-item "second")
     (make-item "third"))))

(make-list ". ")</lang>

Output:

1. first
2. second
3. third

Common Lisp

<lang lisp>(defun my-make-list (separator)

 (let ((counter 0))
   (flet ((make-item (item)
             (format nil "~a~a~a~%" (incf counter) separator item)))
     (concatenate 'string
                  (make-item "first")
                  (make-item "second")
                  (make-item "third")))))

(format t (my-make-list ". "))</lang>

PS: A function named make-list is already defined in Common Lisp, see specification.

Cowgol

<lang cowgol>include "cowgol.coh"; include "strings.coh";

sub MakeList(sep: [uint8], buf: [uint8]): (out: [uint8]) is

   out := buf; # return begin of buffer for ease of use
   var counter: uint32 := 0;

   # Add item to string
   sub AddStr(str: [uint8]) is
       var length := StrLen(str);
       MemCopy(str, length, buf);
       buf := buf + length;
   end sub;

   sub MakeItem(item: [uint8]) is
       counter := counter + 1;
       buf := UIToA(counter, 10, buf);
       AddStr(sep);
       AddStr(item);
       AddStr("\n");
   end sub;

   MakeItem("first");
   MakeItem("second");
   MakeItem("third");
   [buf] := 0; # terminate string

end sub;

var buffer: uint8[100];

print(MakeList(". ", &buffer as [uint8]));</lang>

Output:

1. first
2. second
3. third

D

<lang d>string makeList(string seperator) {

   int counter = 1;

   string makeItem(string item) {
       import std.conv : to;
       return to!string(counter++) ~ seperator ~ item ~ "\n";
   }

   return makeItem("first") ~ makeItem("second") ~ makeItem("third");

}

void main() {

   import std.stdio : writeln;
   writeln(makeList(". "));

}</lang>

Delphi

See Pascal

Elena

ELENA 5.0 : <lang elena>import extensions;

MakeList(separator) {

   var counter := 1;

   var makeItem := (item){ var retVal := counter.toPrintable() + separator + item + (forward newLine); counter += 1; ^ retVal };

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

}

public program() {

   console.printLine(MakeList(". "))

}</lang>

Output:

1. first
2. second
3. third

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: <lang elixir>defmodule Nested do

 def makeList(separator) do
   counter = 1
   
   makeItem = fn {}, item ->
                     {"#{counter}#{separator}#{item}\n", counter+1}
                 {result, counter}, item ->
                     {result <> "#{counter}#{separator}#{item}\n", counter+1}
              end
   
   {} |> makeItem.("first") |> makeItem.("second") |> makeItem.("third") |> elem(0)
 end

end

IO.write Nested.makeList(". ")</lang>

Output:

1. first
2. second
3. third

Factor

Words (named functions) cannot be defined with parsing words (such as : or ::) in the definition of another word. However, quotations (anonymous functions) can be. We can easily mimic the required behavior by binding a quotation to a lexical variable named make-item. The only caveat is that we must explicitly call the quotation in order to execute it.

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

<lang factor>USING: io kernel math math.parser locals qw sequences ; IN: rosetta-code.nested-functions

make-list ( separator -- str )

   1 :> counter!    
   [| item |
       counter number>string separator append item append
       counter 1 + counter!
   ] :> make-item
   qw{ first second third } [ make-item call ] map "\n" join

". " make-list write</lang>

Fortran

Arithmetic statement functions

Fortran allows the user to define functions (and subroutines also) but from first Fortran (1958) on these are compiled as separate items and cannot themselves contain the definition of another function (or subroutine) - except for the special form allowing the definition of what is called an arithmetic statement function, such as follows:<lang Fortran> FUNCTION F(X)

      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...
     END</lang>

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 DIST(U,V,W) = etc. 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 T = EXP(X). Since they are for arithmetic they cannot be used for character manipulations, and the CHARACTER variable only appeared with F77.

Containerisation

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.

Such contained routines are not themselves allowed to contain routines, so that the nesting is limited to two levels - except that arithmetic statement functions are available, so that three levels could be employed. Languages such as Algol, pl/i, Pascal, etc. impose no such constraint. <lang Fortran> SUBROUTINE POOBAH(TEXT,L,SEP) !I've got a little list!

      CHARACTER*(*) TEXT	!The supplied scratchpad.
      INTEGER L		!Its length.
      CHARACTER*(*) SEP	!The separator to be used.
      INTEGER N		!A counter.
       L = 0			!No text is in place.
       N = 0			!No items added.
       CALL ADDITEM("first")	!Here we go.
       CALL ADDITEM("second")
       CALL ADDITEM("third")
      CONTAINS		!Madly, defined after usage.
       SUBROUTINE ADDITEM(X)	!A contained routine.
        CHARACTER*(*) X	!The text of the item.
         N = N + 1			!Count another item in.
         TEXT(L + 1:L + 1) = CHAR(ICHAR("0") + N)	!Place the single-digit number.
         L = L + 1			!Rather than mess with unknown-length numbers.
         LX = LEN(SEP)			!Now for the separator.
         TEXT(L + 1:L + LX) = SEP	!Placed.
         L = L + LX			!Advance the finger.
         LX = LEN(X)			!Trailing spaces will be included.
         TEXT(L + 1:L + LX) = X	!Placed.
         L = L + LX			!Advance the finger.
         L = L + 1			!Finally,
         TEXT(L:L) = CHAR(10)		!Append an ASCII line feed. Starts a new line.
       END SUBROUTINE ADDITEM	!That was bitty.
     END SUBROUTINE POOBAH	!But only had to be written once.

     PROGRAM POKE
     CHARACTER*666 TEXT	!Surely sufficient.
     INTEGER L
     CALL POOBAH(TEXT,L,". ")
     WRITE (6,"(A)") TEXT(1:L)
     END</lang>

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 CHARACTER*66 FUNCTION POOBAH(SEP)) 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.

To achieve the required output of one item per line would mean the output of one item at a time, and all the items are packed into TEXT with unknown boundaries. A single character sequence seemed less trouble, but to achieve the one-item-per-line layout meant inserting control codes to start a new line. Oddly, the CHAR(10) is the linefeed character in ASCII but on this windows system it is treated as CRLF whereas CR returned to the start of the line with no advance. If output were to go to an old-style lineprinter, such in-line control codes would not be recognised.

Placing all the texts into one "pool" storage area saves space when items are a different length, but items can only be accessed sequentially. If item i were desired, it can only be found after stepping along from the start and if the collection expands beyond a few dozen items, repeated random access soon becomes slow. If this is important, rather than have the items separated by a special in-line symbol one can instead have an array of fingers to say the end of each item's text, which can thereby contain any symbol. In this case the pooled storage for the texts wastes no space on special symbols but this index array must have some predefined size (and be capable of indexing the size of the pool: 8-bits? 16-bits? 32-bits?), so once again, how long is a piece of string?

When storage is abundant

Another way of providing a "list" is via an array as in CHARACTER*28 TEXT(9)) so that each item occupied one element, and the maddening question "how long is a piece of string" arises twice: how much storage to allow for each element when all must be as long as the longest text expected, and, how many elements are to be allowed for.<lang Fortran> SUBROUTINE POOBAH(TEXT,N,SEP) !I've got a little list!

      CHARACTER*(*) TEXT(*)	!The supplied scratchpad.
      INTEGER N		!Entry count.
      CHARACTER*(*) SEP	!The separator to be used.
       N = 0			!No items added.
       CALL ADDITEM("first")	!Here we go.
       CALL ADDITEM("second")
       CALL ADDITEM("third")
      CONTAINS		!Madly, defined after usage.
       SUBROUTINE ADDITEM(X)	!A contained routine.
        CHARACTER*(*) X	!The text of the item to add.
         N = N + 1			!Count another item in.
         WRITE (TEXT(N),1) N,SEP,X	!Place the N'th text, suitably decorated..
   1     FORMAT (I1,2A)		!Allowing only a single digit.
       END SUBROUTINE ADDITEM	!That was simple.
     END SUBROUTINE POOBAH	!Still worth a subroutine.

     PROGRAM POKE
     CHARACTER*28 TEXT(9)	!Surely sufficient.
     INTEGER N
     CALL POOBAH(TEXT,N,". ")
     WRITE (6,"(A)") (TEXT(I)(1:LEN_TRIM(TEXT(I))), I = 1,N)
     END</lang>

The output statement could be WRITE (6,"(A)") TEXT(1:N) 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, FORMAT (I2,2A) 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. 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 N as well as the TEXT 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.

Free Pascal

<lang pascal>// In Pascal, functions always _have_ to return _some_ value, // but the the task doesn’t specify what to return. // Hence makeList and makeItem became procedures. procedure makeList(const separator: string); // The var-section for variables that ought to be accessible // in the routine’s body as well as the /nested/ routines // has to appear /before/ the nested routines’ definitions. var counter: 1..high(integer);

procedure makeItem; begin write(counter, separator); case counter of 1: begin write('first'); end; 2: begin write('second'); end; 3: begin write('third'); end; end; writeLn(); counter := counter + 1; end; // You can insert another var-section here, but variables declared // in this block would _not_ be accessible in the /nested/ routine. begin counter := 1; makeItem; makeItem; makeItem; end;</lang>

FreeBASIC

FreeBASIC does not currently support either nested procedures or lambda expressions. The best we can do here is to create two separate procedures but pass the state of the first procedure by reference to the second procedure so it can be modified by the latter.

<lang freebasic>' FB 1.05.0 Win64

Sub makeItem(sep As String, ByRef counter As Integer, text As String)

 counter += 1
 Print counter; sep; text 

End Sub

Sub makeList(sep As String)

 Dim a(0 To 2) As String = {"first", "second", "third"} 
 Dim counter As Integer = 0
 While counter < 3
   makeItem(sep, counter, a(counter))
 Wend

End Sub

makeList ". " Print Print "Press any key to quit" Sleep </lang>

Output:

 1. first
 2. second
 3. third

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

Go

<lang go>package main import "fmt"

func makeList(separator string) string {

   counter := 1

   makeItem := func(item string) string {
       result := fmt.Sprintf("%d%s%s\n", counter, separator, item)
       counter += 1
       return result
   }

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

}

func main() {

   fmt.Print(makeList(". "))

}</lang>

Haskell

<lang haskell>import Control.Monad.ST import Data.STRef

makeList :: String -> String makeList separator = concat $ runST $ do

 counter <- newSTRef 1
 let makeItem item = do
       x <- readSTRef counter
       let result = show x ++ separator ++ item ++ "\n"
       modifySTRef counter (+ 1)
       return result
 mapM makeItem ["first", "second", "third"]

main :: IO () main = putStr $ makeList ". "</lang>

Io

<lang Io>makeList := method(separator,

   counter := 1
   makeItem := method(item,
       result := counter .. separator .. item .. "\n"
       counter = counter + 1
       result
   )
   makeItem("first") .. makeItem("second") .. makeItem("third")

) makeList(". ") print</lang>

J

J does not have nested scopes, so they must be emulated. (The design philosophy here is that nesting tends to become difficult to understand when taken too far, so the coder and designer should be mildly penalized with extra work for choosing nesting as opposed to some other problem solving approach.)

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:

<lang J>MakeList=: dyad define

 sep_MakeList_=: x
 cnt_MakeList_=: 0
 ;MakeItem each y

)

MakeItem=: verb define

 cnt_MakeList_=: cnt_MakeList_+1
 (":cnt_MakeList_),sep_MakeList_,y,LF

)</lang>

Example use:

<lang J> '. ' MakeList 'first';'second';'third' 1. first 2. second 3. third </lang>

Java

Works with: Java version 8

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 int variable; the closest way to emulate it is the AtomicInteger class.

<lang java>import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Function;

public class NestedFunctionsDemo {

   static String makeList(String separator) {
       AtomicInteger counter = new AtomicInteger(1);

       Function<String, String> makeItem = item -> counter.getAndIncrement() + separator + item + "\n";

       return makeItem.apply("first") + makeItem.apply("second") + makeItem.apply("third");
   }

   public static void main(String[] args) {
       System.out.println(makeList(". "));
   }

}</lang>

JavaScript

<lang javascript>function makeList(separator) {

 var counter = 1;

 function makeItem(item) {
   return counter++ + separator + item + "\n";
 }

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

}

console.log(makeList(". "));</lang>

jq

<lang jq>def makeList(separator):

 # input: {text: _, counter: _}
 def makeItem(item):
    (.counter + 1) as $counter
    | .text += "\($counter)\(separator)\(item)\n"
    | .counter = $counter;

  {text:"", counter:0} | makeItem("first") | makeItem("second") | makeItem("third") 
  | .text

makeList(". ")</lang>

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

   $ jq -n -r -f program.jq

produces:

1. first
2. second
3. third

Jsish

From Javascript entry. <lang javascript>/* Nested function, in Jsish */ function makeList(separator) {

 var counter = 1;

 function makeItem(item) {
   return counter++ + separator + item + "\n";
 }

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

}

makeList('. ');

/*

!EXPECTSTART!

makeList('. ') ==> 1. first 2. second 3. third

!EXPECTEND!

• /</lang>

Output:

prompt$ jsish -u nestedFunction.jsi
[PASS] nestedFunction.jsi

Julia

Works with: Julia version 0.6

<lang julia>function makelist(sep::String)

   cnt = 1

   function makeitem(item::String)
       rst = string(cnt, sep, item, '\n')
       cnt += 1
       return rst
   end

   return makeitem("first") * makeitem("second") * makeitem("third")

end

print(makelist(". "))</lang>

Kotlin

<lang scala>// version 1.0.6

fun makeList(sep: String): String {

   var count = 0
   fun makeItem(item: String): String {
       count++
       return "$count$sep$item\n"
   }    
   return makeItem("first") + makeItem("second") + makeItem("third")

}

fun main(args: Array<String>) {

   print(makeList(". "))

}</lang>

Output:

1. first
2. second
3. third

Lua

<lang lua>function makeList (separator)

   local counter = 0
   local function makeItem(item)
           counter = counter + 1
           return counter .. separator .. item .. "\n"
       end
   return makeItem("first") .. makeItem("second") .. makeItem("third")

end

print(makeList(". "))</lang>

Output:

1. first
2. second
3. third

M2000 Interpreter

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).

<lang M2000 Interpreter> Module Checkit {

     Make_List(". ")
     Sub Make_List(Separator$)
           Local Counter=0
           Make_Item("First")
           Make_Item("Second")
           Make_Item("Third")
     End Sub
     Sub Make_Item(Item_Name$)
           Counter++
           Print Str$(Counter,"")+Separator$+Item_Name$
     End Sub

} Checkit

Module Make_List {

     Global Counter=0, Separator$=Letter$
     Make_Item("First")
     Make_Item("Second")
     Make_Item("Third")
     
     Sub Make_Item(Item_Name$)
           Counter++
           Print Str$(Counter,"")+Separator$+Item_Name$
     End Sub

}

Make_List ". "

Module Make_List1 {

     Global Counter=0, Separator$=Letter$
     Module Make_Item (Item_Name$) {
           Counter++
           Print Str$(Counter,"")+Separator$+Item_Name$
     }
     Make_Item "First" 
     Make_Item "Second" 
     Make_Item "Third" 

}

Make_List1 ". " </lang>

Maple

<lang Maple> makelist:=proc() local makeitem,i; i:=1; makeitem:=proc(i) if i=1 then printf("%a\n", "1. first"); elif i=2 then printf("%a\n","2. second"); elif i=3 then printf("%a\n", "3. third"); else return NULL; end if; end proc; while i<4 do makeitem(i); i:=i+1; end do; end proc;

</lang>

Mathematica/Wolfram Language

<lang Mathematica>makeList[sep_String]:=Block[

 {counter=0, makeItem},
 makeItem[item_String]:=ToString[++counter]<>sep<>item;
 makeItem /@ {"first", "second", "third"}
 ]

Scan[Print, makeList[". "]]</lang>

min

Works with: min version 0.19.3

Note the @ sigil is the key to altering counter in the outer scope. <lang min>(

 :separator
 1 :counter
 (
   :item
   item separator counter string ' append append "" join
   counter succ @counter
 ) :make-item
 ("first" "second" "third") 'make-item map "\n" join

) :make-list

". " make-list print</lang>

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. <lang MiniScript>makeList = function(sep)

   counter = 0
   makeItem = function(item)
       outer.counter = counter + 1
       return counter + sep + item
   end function
   return [makeItem("first"), makeItem("second"), makeItem("third")]

end function

print makeList(". ")</lang> Output:

["1. first", "2. second", "3. third"]

Nanoquery

Translation of: Python

<lang Nanoquery>def makeList(separator) counter = 1

def makeItem(item) result = str(counter) + separator + item + "\n" counter += 1 return result end

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

println makeList(". ")</lang>

Nim

<lang nim>proc makeList(separator: string): string =

 var counter = 1
 
 proc makeItem(item: string): string =
   result = $counter & separator & item & "\n"
   inc counter
 
 makeItem("first") & makeItem("second") & makeItem("third")

echo $makeList(". ")</lang>

Output:

1. first
2. second
3. third

Objective-C

<lang objc>NSString *makeList(NSString *separator) {

 __block int counter = 1;
 
 NSString *(^makeItem)(NSString *) = ^(NSString *item) {
   return [NSString stringWithFormat:@"%d%@%@\n", counter++, separator, item];
 };
 
 return [NSString stringWithFormat:@"%@%@%@", makeItem(@"first"), makeItem(@"second"), makeItem(@"third")];

}

int main() {

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

}</lang>

OCaml

<lang ocaml>let make_list separator =

 let counter = ref 1 in

 let make_item item =
   let result = string_of_int !counter ^ separator ^ item ^ "\n" in
   incr counter;
   result
 in

 make_item "first" ^ make_item "second" ^ make_item "third"

let () =

 print_string (make_list ". ")</lang>

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:

Output:

3. first
2. second
1. third

Pascal

See Free Pascal

Perl

<lang perl>sub makeList {

   my $separator = shift;
   my $counter = 1;

   sub makeItem { $counter++ . $separator . shift . "\n" }

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

}

print makeList(". ");</lang>

Phix

There is only partial support for nested functions in Phix. Some prior work (over a single afternoon) has been left unfinished, anyone interested can see it at Nested_function/Phix, but it was just enough to open the door for the two following reasonably acceptable work-arounds.
Note that in both the following you cannot reference any local variables or parameters of the containing function, but must pass in everything you need explicitly, and anything you need to update must be a reference type, which is only dictionaries and class instances, not integers, atoms, sequences, strings, or any user-defined types, as they are all effectively read-only. Referring to identifiers in the containing/outer function issues proper errors in 1.0.0 and later, prior to that it simply won't work as hoped for.

using a dictionary

<lang Phix>function MakeList(string sep=". ")

   function MakeItem(integer env, string sep)
       integer counter = getd("counter",env)+1
       setd("counter",counter,env)
       return sprintf("%d%s%s",{counter,sep,{"first","second","third"}[counter]})
   end function
   integer counter = new_dict(Template:"counter",0)
   sequence res = {}
   for i=1 to 3 do
       res = append(res,MakeItem(counter,sep))
   end for
   return res

end function

?MakeList()</lang>

Output:

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

using a class

Library: Phix/Class

Same output. I trust it is obvious that if you passed in c.count, you would not be able to update it. Again note how MakeList's sep must be explicitly re-passed to MakeItem.
Also note that the counter class cannot be made private to MakeList, however as a non-global it would automatically be private to a single source code file. <lang Phix>class counter

   public integer count

end class function MakeList(string sep=". ")

   function MakeItem(counter c, string sep)
       c.count += 1
       return sprintf("%d%s%s",{c.count,sep,{"first","second","third"}[c.count]})
   end function
   counter c = new()
   sequence res = {}
   for i=1 to 3 do
       res = append(res,MakeItem(c,sep))
   end for
   return res

end function

?MakeList()</lang>

PHP

Works with: PHP version 5.3+

<lang php><? function makeList($separator) {

 $counter = 1;

 $makeItem = function ($item) use ($separator, &$counter) {
   return $counter++ . $separator . $item . "\n";
 };

 return $makeItem("first") . $makeItem("second") . $makeItem("third");

}

echo makeList(". "); ?></lang>

PicoLisp

<lang PicoLisp>(de makeList (Sep)

  (let (Cnt 0  makeItem '((Str) (prinl (inc 'Cnt) Sep Str)))
     (makeItem "first")
     (makeItem "second")
     (makeItem "third") ) )

(makeList ". ")</lang>

Python

Works with: Python version 3+

<lang python>def makeList(separator):

   counter = 1

   def makeItem(item):
       nonlocal counter
       result = str(counter) + separator + item + "\n"
       counter += 1
       return result

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

print(makeList(". "))</lang>

R

This also shows that cat's sep argument is not the same as MakeList's. <lang r>MakeList <- function(sep) {

 counter <- 0
 MakeItem <- function() paste0(counter <<- counter + 1, sep, c("first", "second", "third")[counter])
 cat(replicate(3, MakeItem()), sep = "\n")

} MakeList(". ")</lang>

Output:

1. first
2. second
3. third

Racket

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

<lang racket>#lang racket

(define (make-list separator)

 (define counter 1)

 (define (make-item item)
   (begin0
     (format "~a~a~a~%" counter separator item)
     (set! counter (add1 counter))))

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

(display (make-list ". "))</lang>

Output:

1. first
2. second
3. third

Raku

(formerly Perl 6)

<lang perl6>sub make-List ($separator = ') '){

   my $count = 1;

   sub make-Item ($item) { "{$count++}$separator$item" }

   join "\n", <first second third>».&make-Item;

}

put make-List('. ');</lang>

Output:

1. first
2. second
3. third

REXX

This REXX version is modeled after the FreeBASIC example   (and it has the same limitations). <lang rexx>/*REXX program demonstrates that functions can be nested (an outer and inner function).*/ ctr= 0 /*initialize the CTR REXX variable.*/ call MakeList '. ' /*invoke MakeList with the separator.*/ exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ MakeItem: parse arg sep,text; ctr= ctr + 1 /*bump the counter variable. */

         say ctr  ||  sep  ||  word($, ctr)     /*display three thingys ───► terminal. */
         return

/*──────────────────────────────────────────────────────────────────────────────────────*/ MakeList: parse arg sep; $= 'first second third' /*obtain an argument; define a string.*/

                    do  while  ctr<3            /*keep truckin'  until  finished.      */
                    call MakeItem  sep, $       /*invoke the   MakeItem   function.    */
                    end   /*while*/
         return</lang>

output   when using the default input:

1. first
2. second
3. third

Ring

<lang ring>

1. Project : Nested function

makeList(". ") func makeitem(sep, counter, text)

      see "" + counter + sep + text + nl

func makelist(sep)

      a = ["first", "second", "third"] 
      counter = 0
      while counter < 3
               counter = counter + 1
               makeitem(sep, counter, a[counter])
      end

</lang> Output:

1. first
2. second
3. third

Ruby

<lang ruby>def makeList(separator)

 counter = 1

 makeItem = lambda {|item|
   result = "#{counter}#{separator}#{item}\n"
   counter += 1
   result
 }

 makeItem["first"] + makeItem["second"] + makeItem["third"]

end

print makeList(". ")</lang>

Rust

<lang Rust>fn make_list(sep: &str) -> String {

   let mut counter = 0;
   let mut make_item = |label| {
       counter += 1;
       format!("{}{}{}", counter, sep, label)
   };
   format!(
       "{}\n{}\n{}",
       make_item("First"),
       make_item("Second"),
       make_item("Third")
   )

}

fn main() {

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

}</lang>

Output:

1. First
2. Second
3. Third

Scala

  <lang Scala>
  def main(args: Array[String]) {
     val sep: String=". "
     var c:Int=1;
     def go(s: String):Unit={
         println(c+sep+s)
         c=c+1
     }
     go("first")
     go("second")
     go("third")
  }
 </lang>

Output:

1. first
2. second
3. third

Scheme

<lang scheme>(define (make-list separator)

 (define counter 1)
 
 (define (make-item item)
   (let ((result (string-append (number->string counter) separator item "\n")))
     (set! counter (+ counter 1))
     result))
 
 (string-append (make-item "first") (make-item "second") (make-item "third")))

(display (make-list ". "))</lang>

Seed7

<lang seed7>$ include "seed7_05.s7i";

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

 result
   var string: itemList is "";
 local
   var integer: counter is 1;

   const func string: makeItem (in string: item) is func
     result
       var string: anItem is "";
     begin
       anItem := counter <& separator <& item <& "\n";

incr(counter);

     end func

 begin
   itemList := makeItem("first") & makeItem("second") & makeItem("third");
 end func;

const proc: main is func

 begin
   write(makeList(". "));
 end func;</lang>

Output:

1. first
2. second
3. third

Sidef

<lang ruby>func make_list(separator = ') ') {

   var count = 1
   func make_item(item) {
       [count++, separator, item].join
   }

   <first second third>.map(make_item).join("\n")

}

say make_list('. ')</lang>

Output:

1. first
2. second
3. third

Simula

<lang simula>COMMENT CLASS SIMSET IS SIMULA'S STANDARD LINKED LIST DATA TYPE

       CLASS HEAD IS THE LIST ITSELF
       CLASS LINK IS THE ELEMENT OF A LIST
       PROCEDURE IS THE TERM USED FOR FUNCTIONS IN SIMULA
       TEXT IS THE TERM USED FOR STRINGS IN SIMULA ;

SIMSET BEGIN

   LINK CLASS ITEM(TXT); TEXT TXT;;

   COMMENT CREATING THE LIST AS A WHOLE WITH THE SEPARATOR ". "
           GIVEN AS AN ARGUMENT;
   REF(HEAD) PROCEDURE MAKELIST(SEPARATOR); TEXT SEPARATOR;
   BEGIN
       COMMENT VARIABLE TO KEEP TRACK OF THE ITEM NUMBER ;
       INTEGER COUNTER;

       COMMENT THIS IS THE NESTED FUNCTION ;
       REF(ITEM) PROCEDURE MAKEITEM(TXT); TEXT TXT;
       BEGIN
           TEXT NUM;
           TEXT ITEMTEXT;

           COMMENT CONVERT NUMBER TO STRING ;
           NUM :- BLANKS(5);
           NUM.PUTINT(COUNTER);

           COMMENT ACCESS SEPARATOR AND MODIFY COUNTER;
           COUNTER := COUNTER + 1;
           ITEMTEXT :- NUM & SEPARATOR & TXT;

           MAKEITEM :- NEW ITEM(ITEMTEXT);
       END MAKEITEM;

       REF(HEAD) HD;
       HD :- NEW HEAD;
       COUNTER := 1;
       MAKEITEM("FIRST").INTO(HD);
       MAKEITEM("SECOND").INTO(HD);
       MAKEITEM("THIRD").INTO(HD);
       MAKELIST :- HD;
   END MAKELIST;

   REF(HEAD) LIST;
   REF(ITEM) IT;
   LIST :- MAKELIST(". ");

   COMMENT NAVIGATE THROUGH THE LIST ;
   IT :- LIST.FIRST;
   WHILE IT =/= NONE DO
   BEGIN
       OUTTEXT(IT.TXT);
       OUTIMAGE;
       IT :- IT.SUC;
   END;

END. </lang>

Output:

    1. FIRST
    2. SECOND
    3. THIRD

Standard ML

<lang sml>fun make_list separator =

 let
   val counter = ref 1;
   fun make_item item =
     let
       val result = Int.toString (!counter) ^ separator ^ item ^ "\n"
     in
       counter := !counter + 1;
       result
     end
 in
   make_item "first" ^ make_item "second" ^ make_item "third"
 end;

print (make_list ". ")</lang>

SuperCollider

<lang SuperCollider>( f = { |separator| var count = 0; var counting = { |name| count = count + 1; count.asString ++ separator + name ++ "\n" }; counting.("first") + counting.("second") + counting.("third") }; )

f.(".") </lang>

Swift

<lang swift>func makeList(_ separator: String) -> String {

 var counter = 1
 
 func makeItem(_ item: String) -> String {
   let result = String(counter) + separator + item + "\n"
   counter += 1
   return result
 }
 
 return makeItem("first") + makeItem("second") + makeItem("third")

}

print(makeList(". "))</lang>

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 <lang Tcl>#!/usr/bin/env tclsh

proc MakeList separator {

   set counter 1
   proc MakeItem string {

upvar 1 separator separator counter counter set res $counter$separator$string\n incr counter return $res

   }
   set res [MakeItem first][MakeItem second][MakeItem third]
   rename MakeItem {}
   return $res

} puts [MakeList ". "] </lang>

VBA

<lang vb>Option Explicit

Private Const Sep As String = ". " Private Counter As Integer Sub Main() Dim L As Variant

   Counter = 0
   L = MakeList(Array("first", "second", "third"))
   Debug.Print L

End Sub Function MakeList(Datas) As Variant Dim i As Integer

   For i = LBound(Datas) To UBound(Datas)
       MakeList = MakeList & MakeItem(Datas(i))
   Next i

End Function Function MakeItem(Item As Variant) As Variant

   Counter = Counter + 1
   MakeItem = Counter & Sep & Item & vbCrLf

End Function</lang>

Output:

1. first
2. second
3. third

Wren

<lang ecmascript>var makeList = Fn.new { |sep|

   var counter = 0
   var makeItem = Fn.new { |name|
       counter = counter + 1
       return "%(counter)%(sep)%(name)"
   }
   var items = []
   for (name in ["first", "second", "third"]) {
       items.add(makeItem.call(name))
   }
   System.print(items.join("\n"))

}

makeList.call(". ")</lang>

Output:

1. first
2. second
3. third

XPL0

<lang XPL0>proc MakeList(Separator); char Separator; int Counter;

   proc MakeItem;
   int  Ordinals;
   [IntOut(0, Counter);
   Text(0, Separator);
   Ordinals:= [0, "first", "second", "third"];
   Text(0, Ordinals(Counter));
   CrLf(0);
   ];

for Counter:= 1 to 3 do MakeItem; \MakeList procedure

MakeList(". ") \main procedure</lang>

Output:

1. first
2. second
3. third

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. <lang zkl>fcn makeList(separator){

 counter:=Ref(1);  // a container holding a one. A reference.
 // 'wrap is partial application, in this case binding counter and separator
 makeItem:='wrap(item){ c:=counter.inc(); String(c,separator,item,"\n") };
 makeItem("first") + makeItem("second") + makeItem("third")

}

print(makeList(". "));</lang>

Output:

1. first
2. second
3. third