Nested function: Difference between revisions
algol 68 sample added |
|||
Line 14: | Line 14: | ||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}} |
|||
<lang algol68>PROC make list = ( STRING separator )STRING: |
<lang algol68>PROC make list = ( STRING separator )STRING: |
||
BEGIN |
BEGIN |
Revision as of 18:59, 18 September 2016
In many languages, functions can be nested, so there are outer functions and inner functions. The inner function can then access the variables of the outer function. In most languages, the inner function can also modify variables from the outer function.
See: Wikipedia: Nested function article.
The following examples for MakeList or makeList generate the following text:
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>
C#
<lang csharp>string MakeList(string separator) {
var counter = 1;
var makeItem = new Func<string, string>((item) => { return counter++ + separator + item + "\n"; });
return makeItem("first") + makeItem("second") + makeItem("third");
}
Console.WriteLine(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>
Lua
<lang lua>function makeList(separator)
local counter = 1
local function makeItem(item) return counter .. separator .. item .. "\n" end
return makeItem("first") .. makeItem("second") .. makeItem("third")
end
print(makeList(". "))</lang>
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>
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>
PHP
<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>
Python
<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>
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>
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>
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