Procedural parameter - Revision history

Bearian: /* See also */==References== {{reflist}}

2025-05-14T00:45:42Z

Brightlightshine: /* growthexperiments-addlink-summary-summary:3|0|0 */

2025-02-28T01:22:35Z

Link suggestions feature: 3 links added.

← Previous revision		Revision as of 01:22, 28 February 2025
Line 57:		Line 57:
	''i'' ← ''i''+1;		''i'' ← ''i''+1;

	This procedure can be used to sort the elements ''x''[''a''] through ''x''[''b''] of some array ''x'', of arbitrary [[datatype\|type]], in a user-specified order. The parameters ''prec'' and ''swap'' should be two [[function (computing)\|function]]s, defined by the [[client (programming)\|client]], both taking two integers ''r'', ''s'' between ''a'' and ''b''. The ''prec'' function should return '''true''' if and only if the data stored in ''x''[''r''] should precede the data stored in ''x''[''s''], in the ordering defined by the client. The ''swap'' function should exchange the contents of ''x''[''r''] and ''x''[''s''], and return no result.		This procedure can be used to sort the elements ''x''[''a''] through ''x''[''b''] of some array ''x'', of arbitrary [[datatype\|type]], in a user-specified order. The parameters ''prec'' and ''swap'' should be two [[function (computing)\|function]]s, defined by the [[client (programming)\|client]], both taking two integers ''r'', ''s'' between ''a'' and ''b''. The ''prec'' function should return '''true''' [[if and only if]] the data stored in ''x''[''r''] should precede the data stored in ''x''[''s''], in the ordering defined by the client. The ''swap'' function should exchange the contents of ''x''[''r''] and ''x''[''s''], and return no result.

	By the proper choice of the functions ''prec'' and ''swap'', the same ''isort'' procedure can be used to reorder arrays of any data type, stored in any medium and organized in any data structure that provides indexed access to individual array elements. (Note however that there are [[sorting algorithm]]s that are much more efficient than insertion sort for large arrays.)		By the proper choice of the functions ''prec'' and ''swap'', the same ''isort'' procedure can be used to reorder arrays of any data type, stored in any medium and organized in any [[data structure]] that provides indexed access to individual array elements. (Note however that there are [[sorting algorithm]]s that are much more efficient than insertion sort for large arrays.)

	===Sorting floating-point numbers===		===Sorting floating-point numbers===
Line 114:		Line 114:

	==Example: merging two sequences==		==Example: merging two sequences==
	The following example illustrates the use of procedural parameters to process abstract data structures independently of their concrete implementation. The problem is to merge two ordered sequences of records into a single sorted sequence, where the nature of the records and the ordering criterion can be chosen by the client. The following implementation assumes only that each record can be referenced by a memory address, and there is a "null address" Λ that is not the address of any valid record. The client must provide the addresses ''A'', ''B'' of the first records in each sequence, and functions ''prec'', ''next'', and ''append'', to be described later.		The following example illustrates the use of procedural parameters to process abstract data structures independently of their concrete implementation. The problem is to merge two ordered sequences of records into a single sorted sequence, where the nature of the records and the ordering criterion can be chosen by the client. The following implementation assumes only that each record can be referenced by a [[memory address]], and there is a "null address" Λ that is not the address of any valid record. The client must provide the addresses ''A'', ''B'' of the first records in each sequence, and functions ''prec'', ''next'', and ''append'', to be described later.

	'''procedure''' ''merge''(''A'', ''B'', ''prec'', ''nextA'', ''appendA'', ''nextB'', ''appendB''):		'''procedure''' ''merge''(''A'', ''B'', ''prec'', ''nextA'', ''appendA'', ''nextB'', ''appendB''):

Certes: improve link: Mathematician (via WP:JWB)

2022-03-24T22:00:01Z

improve link: Mathematician (via WP:JWB)

← Previous revision		Revision as of 22:00, 24 March 2022
Line 212:		Line 212:

	==History==		==History==
	<!--DATES NEEDED-->Procedural parameters were invented before the age of electronic computers, by [[~~mathematics\|~~mathematician]] [[Alonzo Church]], as part of his [[lambda calculus]] model of computation.		<!--DATES NEEDED-->Procedural parameters were invented before the age of electronic computers, by [[mathematician]] [[Alonzo Church]], as part of his [[lambda calculus]] model of computation.

	Procedural parameters as a programming language feature were introduced by [[ALGOL 60 programming language\|ALGOL 60]].<!--DID FORTRAN IV HAVE SOMETHING LIKE THAT TOO? NOT SURE...--> In fact, ALGOL 60 had a powerful "[[call by name]]" parameter-passing mechanism that could simplify some uses of procedural parameters; see [[Jensen's Device]].		Procedural parameters as a programming language feature were introduced by [[ALGOL 60 programming language\|ALGOL 60]].<!--DID FORTRAN IV HAVE SOMETHING LIKE THAT TOO? NOT SURE...--> In fact, ALGOL 60 had a powerful "[[call by name]]" parameter-passing mechanism that could simplify some uses of procedural parameters; see [[Jensen's Device]].

Ira Leviton: Rewrote some mathematical terms using math font so they are not mistaken for typos by automated spellcheckers. Many others still need to be converted.

2021-06-23T20:28:51Z

Rewrote some mathematical terms using math font so they are not mistaken for typos by automated spellcheckers. Many others still need to be converted.

← Previous revision		Revision as of 20:28, 23 June 2021
Line 188:		Line 188:

	===Integrating over a disk===		===Integrating over a disk===
	Consider now the problem of integrating a given function ''g'', with two arguments, over a disk ''D'' with given center (''xc'',''yc'') and given radius ''R''. This problem can be reduced to two nested single-variable integrals by the change of variables		Consider now the problem of integrating a given function <math>g</math>, with two arguments, over a disk <math>D</math> with given center (<math>xc,yc</math>) and given radius <math>R</math>. This problem can be reduced to two nested single-variable integrals by the change of variables

	:<math>\int\!\int_D g(x,y)\, \mathrm{d}x\, \mathrm{d}y = \int_0^R z \left(\int_0^{2\pi} g(\mathit{xc}+z \cos t ,\mathit{yc}+z \sin t ) \,\mathrm{d}t\right)\,\mathrm{d}z</math>		:<math>\int\!\int_D g(x,y)\, \mathrm{d}x\, \mathrm{d}y = \int_0^R z \left(\int_0^{2\pi} g(\mathit{xc}+z \cos t ,\mathit{yc}+z \sin t ) \,\mathrm{d}t\right)\,\mathrm{d}z</math>
Line 209:		Line 209:
	'''return''' ''Intg''(''gring'', 0, ''R'', ''n'')		'''return''' ''Intg''(''gring'', 0, ''R'', ''n'')

	This code uses the integration procedure ''Intg'' in two levels. The outer level (last line) uses ''Intg'' to compute the integral of ''gring''(''z'') for ''z'' varying from 0 to ''R''. The inner level (next-to-last line) defines ''gring''(''z'') as being the [[line integral]] of ''g''(''x'',''y'') over the circle with center (''xc'',''yc'') and radius ''z''.		This code uses the integration procedure ''Intg'' in two levels. The outer level (last line) uses ''Intg'' to compute the integral of <math>gring(z)</math> for <math>z</math> varying from 0 to <math>R</math>. The inner level (next-to-last line) defines <math>gring(z)</math> as being the [[line integral]] of <math>g(x,y)</math> over the circle with center <math>(xc,yc)</math> and radius <math>z</math>.

	==History==		==History==

Frap: Format code

2020-10-21T10:13:58Z

Format code

← Previous revision		Revision as of 10:13, 21 October 2020
Line 97:		Line 97:

	'''procedure''' ''vprec''(''r'', ''s''):		'''procedure''' ''vprec''(''r'', ''s''):
	if ''incr'' then		'''if''' ''incr'' '''then'''
	'''return''' ''v''[''r''] < ''v''[''s''];		'''return''' ''v''[''r''] < ''v''[''s''];
	'''else'''		'''else'''
Line 159:		Line 159:

	'''procedure''' ''nextU''(''x''):		'''procedure''' ''nextU''(''x''):
	'''if''' ''x'' = &(''U''[''m''−1]) '''then''' '''return''' Λ '''else''' '''return''' ''x'' + 1		'''if''' ''x'' = &(''U''[''m''−1]) '''then''' '''return''' Λ '''else''' '''return''' ''x'' + 1

	'''procedure''' ''nextV''(''x''):		'''procedure''' ''nextV''(''x''):
Line 205:		Line 205:

	'''integer''' ''m'' ← ''round''(''n''*''z''/''R'')		'''integer''' ''m'' ← ''round''(''n''*''z''/''R'')
	'''return''' ''z''''Intg''(''gpolar'', 0, 2π, ''m'')		'''return''' ''z'' * ''Intg''(''gpolar'', 0, 2*π, ''m'')

	'''return''' ''Intg''(''gring'', 0, ''R'', ''n'')		'''return''' ''Intg''(''gring'', 0, ''R'', ''n'')

Frap: Format code

2020-10-20T13:21:29Z

Format code

Show changes

DannyS712 bot: Task 70: Update syntaxhighlight tags - remove use of deprecated tags

2020-05-11T18:21:24Z

Task 70: Update syntaxhighlight tags - remove use of deprecated <source> tags

← Previous revision		Revision as of 18:21, 11 May 2020
Line 32:		Line 32:
	===Syntactic details===		===Syntactic details===
	Some programming languages that have this feature may allow or require a complete type declaration for each procedural parameter ''f'', including the number and type of its arguments, and the type of its result, if any. For example, in the C programming language the example above could be written as		Some programming languages that have this feature may allow or require a complete type declaration for each procedural parameter ''f'', including the number and type of its arguments, and the type of its result, if any. For example, in the C programming language the example above could be written as
	<~~source~~ lang="c">		<syntaxhighlight lang="c">
	int P ( int (*f)(int a, int b) )		int P ( int (*f)(int a, int b) )
	{ return f(6,3) * f(2,1); }		{ return f(6,3) * f(2,1); }
			</syntaxhighlight>
	</source>
	In principle, the actual function ''actf'' that is passed as argument when ''P'' is called must be type-compatible with the declared type of the procedure parameter ''f''. This usually means that ''actf'' and ''f'' must return the same type of result, must have the same number of arguments, and corresponding arguments must have the same type. The names of the arguments need not be the same, however, as shown by the ''plus'' and ''quot'' examples above. However, some programming languages may be more restrictive or more liberal in this regard.		In principle, the actual function ''actf'' that is passed as argument when ''P'' is called must be type-compatible with the declared type of the procedure parameter ''f''. This usually means that ''actf'' and ''f'' must return the same type of result, must have the same number of arguments, and corresponding arguments must have the same type. The names of the arguments need not be the same, however, as shown by the ''plus'' and ''quot'' examples above. However, some programming languages may be more restrictive or more liberal in this regard.

Raise exception: Change link to "C (programming language)"

2019-09-21T08:38:45Z

Change link to "C (programming language)"

← Previous revision		Revision as of 08:38, 21 September 2019
Line 3:		Line 3:
	This concept is an extremely powerful and versatile [[Computer programming\|programming]] tool, because it allows programmers to modify certain steps of a [[library (computer science)\|library procedure]] in arbitrarily complicated ways, without having to understand or modify the code of that procedure.		This concept is an extremely powerful and versatile [[Computer programming\|programming]] tool, because it allows programmers to modify certain steps of a [[library (computer science)\|library procedure]] in arbitrarily complicated ways, without having to understand or modify the code of that procedure.

	This tool is particularly effective and convenient in languages that support [[nested function\|local function definitions]], such as [[Pascal programming language\|Pascal]] and the modern [[GNU Compiler Collection\|GNU dialect]] of [[C programming language\|C]]. It is even more so when [[closure (computer science)\|function closures]] are available. The same functionality (and more) is provided by [[object (computing)\|object]]s in [[object oriented programming\|object oriented]] [[programming language]]s, but at a significantly higher cost.		This tool is particularly effective and convenient in languages that support [[nested function\|local function definitions]], such as [[Pascal programming language\|Pascal]] and the modern [[GNU Compiler Collection\|GNU dialect]] of [[C (programming language)\|C]]. It is even more so when [[closure (computer science)\|function closures]] are available. The same functionality (and more) is provided by [[object (computing)\|object]]s in [[object oriented programming\|object oriented]] [[programming language]]s, but at a significantly higher cost.

	Procedural parameters are somewhat related to the concepts of [[first-class function]] and [[anonymous function]], but is distinct from them. These two concepts have more to do with how functions are defined, rather than how they are used.		Procedural parameters are somewhat related to the concepts of [[first-class function]] and [[anonymous function]], but is distinct from them. These two concepts have more to do with how functions are defined, rather than how they are used.
Line 215:		Line 215:
	Procedural parameters as a programming language feature were introduced by [[ALGOL 60 programming language\|ALGOL 60]].<!--DID FORTRAN IV HAVE SOMETHING LIKE THAT TOO? NOT SURE...--> In fact, ALGOL 60 had a powerful "[[call by name]]" parameter-passing mechanism that could simplify some uses of procedural parameters; see [[Jensen's Device]].		Procedural parameters as a programming language feature were introduced by [[ALGOL 60 programming language\|ALGOL 60]].<!--DID FORTRAN IV HAVE SOMETHING LIKE THAT TOO? NOT SURE...--> In fact, ALGOL 60 had a powerful "[[call by name]]" parameter-passing mechanism that could simplify some uses of procedural parameters; see [[Jensen's Device]].

	Procedural parameters were an essential feature of the [[LISP programming language]], which also introduced the concept of function closure or [[funarg]]. The [[C programming language]] allows [[function pointers]] to be passed as parameters<!--FROM THE BEGINNING?-->, which accomplish the same end, and are often used as [[callbacks]] in [[event-driven programming]] and as error handlers. However, only a few modern C compilers allow nested function definitions, so that its other uses are relatively uncommon. Procedural parameters were provided also in Pascal, together with nested procedure definitions; however, since standard Pascal did not allow separate compilation, the feature was little used in that language, too.		Procedural parameters were an essential feature of the [[LISP programming language]], which also introduced the concept of function closure or [[funarg]]. The [[C (programming language)\|C programming language]] allows [[function pointers]] to be passed as parameters<!--FROM THE BEGINNING?-->, which accomplish the same end, and are often used as [[callbacks]] in [[event-driven programming]] and as error handlers. However, only a few modern C compilers allow nested function definitions, so that its other uses are relatively uncommon. Procedural parameters were provided also in Pascal, together with nested procedure definitions; however, since standard Pascal did not allow separate compilation, the feature was little used in that language, too.

	==See also==		==See also==

199.58.98.69: That's... not how function pointers work

2019-02-03T04:55:59Z

That's... not how function pointers work

← Previous revision		Revision as of 04:55, 3 February 2019
Line 33:		Line 33:
	Some programming languages that have this feature may allow or require a complete type declaration for each procedural parameter ''f'', including the number and type of its arguments, and the type of its result, if any. For example, in the C programming language the example above could be written as		Some programming languages that have this feature may allow or require a complete type declaration for each procedural parameter ''f'', including the number and type of its arguments, and the type of its result, if any. For example, in the C programming language the example above could be written as
	<source lang="c">		<source lang="c">
	int P ( int f (int a, int b) )		int P ( int (*f)(int a, int b) )
	{ return f(6,3) * f(2,1); }		{ return f(6,3) * f(2,1); }
	</source>		</source>

AnomieBOT: Dating maintenance tags: {{Example needed}}

2018-12-08T12:36:26Z

Dating maintenance tags: {{Example needed}}

← Previous revision		Revision as of 12:36, 8 December 2018
Line 39:		Line 39:

	===Scoping===		===Scoping===
	In languages that allow procedural parameters, the scoping rules are usually defined in such a way that procedural parameters are executed in their native scope. More precisely, suppose that the function ''actf'' is passed as argument to ''P'', as its procedural parameter ''f''; and ''f'' is then called from inside the body of ''P''. While ''actf'' is being executed, it sees the environment of its definition.{{Example needed}}		In languages that allow procedural parameters, the scoping rules are usually defined in such a way that procedural parameters are executed in their native scope. More precisely, suppose that the function ''actf'' is passed as argument to ''P'', as its procedural parameter ''f''; and ''f'' is then called from inside the body of ''P''. While ''actf'' is being executed, it sees the environment of its definition.{{Example needed\|date=December 2018}}

	The implementation of these scoping rules is not trivial. By the time that ''actf'' is finally executed, the [[call stack#Structure\|activation records]] where its environment variables live may be arbitrarily deep in the stack. This is the so-called [[funarg problem#Downwards funarg problem\|downwards funarg problem]].		The implementation of these scoping rules is not trivial. By the time that ''actf'' is finally executed, the [[call stack#Structure\|activation records]] where its environment variables live may be arbitrarily deep in the stack. This is the so-called [[funarg problem#Downwards funarg problem\|downwards funarg problem]].

← Previous revision		Revision as of 00:45, 14 May 2025
Line 223:		Line 223:
	*[[Funarg problem]]		*[[Funarg problem]]
	*[[Design patterns (computer science)]]		*[[Design patterns (computer science)]]

			==References==
			{{reflist}}

	{{Unreferenced\|date=December 2009}}		{{Unreferenced\|date=December 2009}}