• Synopsis

• Description

• Enumerators

• all(fun,array [,max]

• collect(fun,array1,array2 [,max])

• select(fun,array1,array2 [,max])

• reject(fun,array1,array2 [,max])

• detect(fun,array [,max])

• inject(fun,array,carry [,max])

• Sample Functions

• Using the Functions

• Code

• all

• collect

• select

• reject

• detect

• inject

• Bugs

• Author

Synopsis

all( fun, array [,max]

collect( fun, array1, array2 [,max])

select( fun, array1, array2 [,max])

reject( fun, array1, array2 [,max])

detect( fun, array [,max])

inject( fun, array, carry [,max])

All these functions return the size of array or array2

Description

An interesting new feature in Gawk 3.1.7 is indirect functions. This allows the function name to be a variable, passed as an argument to an array, and called using the syntax

@fun(arg1,arg2,...)    

This enables a new kind of funcational programming style in Gawk. For example, generic enumeration patterns can be coded once, then called many different ways with different function names passed as arguments.

This document illustrates this style of programming.

Enumerators

For example, here are some standard enumeration functions:

all(fun,array [,max]

Applies the function fun to all items in the array. If called with the max argument, then they are iterated in the order i=1 .. max, otherwise we use for(i in a).

collect(fun,array1,array2 [,max])

Applies fun to each item in array1 and collects the results in array2.

select(fun,array1,array2 [,max])

Find all the items in array1 that satisfies fun and add them to array2.

reject(fun,array1,array2 [,max])

Find all the items in array1 that do not satisfy fun and add them to array2.

detect(fun,array [,max])

Return the first item found in array that satisfies fun. If no such item is found, then return the magic global value Fail.

inject(fun,array,carry [,max])

(This one is a little tricky.) The result of applying fun to each item in array is carried into the processing of the next item. Initially, the carried value is carry. This function returns the final carry.

Sample Functions

To illusrate the above, consider the following functions. Each of these are defined for one array item.

function odd(x)    { return (x % 2) == 1 }
function show(x)   { print "[" x "]" }
function mult(x,y) { return x * y }
function halve(x)  { return x/2 }

Using the Functions

• All-ing...

function do_all(   arr) { 
    split("22 23 24 25 26 27 28",arr)
    all("show",arr)
}

When we run this ...

eg/enum1

gawk317="$HOME/opt/gawk/bin/gawk"
$gawk317 -f ../enumerate.awk --source 'BEGIN { do_all() }'

we see every item in arr printed using the above show function ...

eg/enum1.out

[25]
[26]
[27]
[28]
[22]
[23]
[24]

• Collect-ing...

function do_collect(        max,arr1,arr2,i) {
    max=split("22 23 24 25 26 27 28",arr1)
    collect("halve",arr1,arr2,max)
    for(i=1;i<=max;i++) print arr2[i]
}

When we run this ...

eg/enum2

gawk317="$HOME/opt/gawk/bin/gawk"
$gawk317 -f ../enumerate.awk --source 'BEGIN { do_collect() }'

we see every item in arr divided in two ...

eg/enum2.out

11
11.5
12
12.5
13
13.5
14

• Select-ing...

function do_select(        all,less,arr1,arr2,i) {
    all  = split("22 23 24 25 26 27 28",arr1)
    less = select("odd",arr1,arr2,all)
    for(i=1;i<=less;i++) print arr2[i]
}

When we run this ...

eg/enum3

gawk317="$HOME/opt/gawk/bin/gawk"
$gawk317 -f ../enumerate.awk --source 'BEGIN { do_select() }'

we see every item in arr that satisfies odd....

eg/enum3.out

23
25
27

• Reject-ing...

function do_reject(        all,less,arr1,arr2,i) {
    all  = split("22 23 24 25 26 27 28",arr1)
    less = reject("odd",arr1,arr2,all)
    for(i=1;i<=less;i++) print arr2[i]
}

When we run this ...

eg/enum4

gawk317="$HOME/opt/gawk/bin/gawk"
$gawk317 -f ../enumerate.awk --source 'BEGIN { do_reject() }'

we see every item in arr that do not satisfies odd....

eg/enum4.out

22
24
26
28

• Detect-ing

function do_detect(        all,arr1) {
    all  = split("22 23 24 25 26 27 28",arr1)
    print detect("odd",arr1,all)   
}

When we run this ...

eg/enum5

gawk317="$HOME/opt/gawk/bin/gawk"
$gawk317 -f ../enumerate.awk --source 'BEGIN { do_detect() }'

we see the first item in arr that satisfies odd....

eg/enum5.out

23

• Inject-ing...

function do_inject(        all,less,arr1,arr2,i) {
    split("1 2 3 4 5",arr1)
    print inject("mult",arr1,1)
}

When we run this ...

eg/enum6

gawk317="$HOME/opt/gawk/bin/gawk"
$gawk317 -f ../enumerate.awk --source 'BEGIN { do_inject() }'

we see every the result of multiplying every item in arr by its predecessor.

eg/enum6.out

120

Code

Note one design principle in the following: any newly generated arrays have indexes 1..max where max is the number of elements in that array.

all

function all (fun,a,max,   i) {
	if (max) 
		for(i=1;i<=max;i++) @fun(a[i]) 
	else  
		for(i in a) @fun(a[i])
}

collect

function collect (fun,a,b,max,   i) {
	if (max)
	    for(i=1;i<=max;i++) {n++; b[i]= @fun(a[i]) }
	else
	    for(i in a) {n++; b[i]= @fun(a[i])}
	return n
}

select

function select (fun,a,b,max,   i,n) {
	if (max)
		for(i=1;i<=max;i++) {
		    if (@fun(a[i])) {n++; b[n]= a[i] }}
	else
		for(i in a) {
		    if (@fun(a[i])) {n++; b[n]= a[i] }}
	return n
}

reject

function reject (fun,a,b,max,   i,n) {
	if (max)
		for(i=1;i<=max;i++) {
		    if (! @fun(a[i])) {n++; b[n]= a[i] }}
	else
		for(i in a) {
		    if (! @fun(a[i])) {n++; b[n]= a[i] }}
	return n
}

detect

BEGIN {Fail="someUnLIKELYSymbol"}
function detect (fun,a,max,   i) {
	if (max)
		for(i=1;i<=max;i++) {
			if (@fun(a[i])) return a[i] }
	else	
		for(i in a) {
			if (@fun(a[i])) return a[i] }
	return Fail
}

inject

function inject (fun,a,carry,max,   i) {
	if (max)
		for(i=1;i<=max;i++)
			 carry = @fun(a[i],carry) 
	else
		for(i in a)
			 carry = @fun(a[i],carry) 
	return carry
}

Bugs

The above code does not pass around any state information that the fum functions can use. So all their deliberations are either with the current array values (integers or strings) or with global state. It might be worthwhile writing new versions of the above with one more argument, to carry that sate.

Author