Higher-order function

Higher-order function - Factbites
Where results make sense
About us | Why use us? | Reviews | PR | Contact us

Topic: Higher-order function

Note: these results are not from the primary (high quality) database.

In the News (Sun 20 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Higher-order function - Wikipedia, the free encyclopedia
		Objects, in an object-oriented programming environment can be used as higher order functions, in the sense that different objects may have different behaviors and thus might be thought of as representing different functions.
		In general, data driven programming methodologies have some of the character of higher order functions, as the data itself determines function, and operations on that data may result in alternate functionality being employed.
		The derivative in calculus is a common example, since it maps a function to another function.
	en.wikipedia.org /wiki/Higher-order_function (551 words)

	Higher-Order Functions as Objects
		In order to implement the equivalent of higher-order functions, we shall have to use objects as functions, since these can be passed as arguments.
		The object-oriented version of higher-order functions might be a little harder to understand than the rex version, which is one reason we wanted to present the rex version first.
		Suppose we want a function which returns a function a function which concatenates a specified prefix, not just "xxx" invariably.
	www.cs.hmc.edu /claremont/keller/webBook/ch07/sec23.html (564 words)

	Functional programming in the Java language
		A higher order function is able to take another function (indirectly, an expression) as its input argument, and in some cases it may even return a function as its output argument.
		From a functional programming standpoint, the expression is not yet a general piece of logic; that is, it cannot be passed around and asked to execute whenever you want, without regard to the current position of execution control.
		Functional programming, on the other hand, is a style of programming that emphasizes the evaluation of expressions rather than the execution of commands.
	www-128.ibm.com /developerworks/library/j-fp.html?ca=dnt-528 (4910 words)

	Higher order functions
		Functional programming in the Java language (developerWorks, July 2004) demonstrates how to use functional programming constructs such as closures and higher order functions to write well-structured, modular code in the Java language.
		Charming Python: Functional programming in Python, Part 3 (developerWorks, June 2001) covers currying (named after the logician Haskell Curry, this allows the return value of functions to themselves be functions but with the returned functions "narrowed") and other high order functions.
		function, in order to get a vector of functions defined over a local environment, you just defined a vector where each member was a function defined within the same environment.
	www-128.ibm.com /developerworks/library/l-highfunc.html?ca=dgr-lnxw1fFunctions (5732 words)

	Es: A shell with higher-order functions
		On the other hand, if the functions are run in a subshell, the connection between their lexical scopes is lost as a consequence of them being exported in separate environment strings.
		When an exception is raised from a shell function, it propagates as expected; if raised from a subshell, it cannot be propagated as one would like it to be: instead, a message is printed on exit from the subshell and a false exit status is returned.
		In the section on functions, we mentioned that function parameters are lexically scoped.
	www.webcom.com /~haahr/es/es-usenix-winter93.html (5809 words)

	Higher Order Functions
		But I'm answering his general question about why are higher order functions are useful and will keep the scheme to a minimum since I don't know enough ML yet to do justice with my answer, though I submit my code is easily and readily translatable into ML.
		And ultimately, since it is a human writing these codes, being able to manipulate operations on data or sets of functions _in a way understandable by someone else_ gives the advantage to using higher order functions.
		The essence of higher-order functions is to abstract away control structures and since they can have state as well(called a closure), they can model objects.
	www.upl.cs.wisc.edu /~psilord/docs/hof.html (824 words)

	Polymorphic and Higher-Order Functions
		When writing a function in ML we gave neither the types of the arguments nor the type of the return value of the function.
		In procedural languages there is a clear distinction between functions and ordinary values; in functional languages this is not the case, and we can treat functions like any other expression, in particular we can use them as parameters and arguments.
		The main use of such functions is when we need them only once, and so do not wish to give them a separate name and definition, on the par with more important functions.
	www.cs.may.ie /~jpower/Courses/ML/fun-poly.html (2575 words)

	Tutorial.4
		To begin, we introduce a function "fromto" which, although not higher order itself, is often used in conjunction with higher order functions.
		HIGHER ORDER FUNCTIONS ---------------------------------------------------------------- *** FUNCTIONS AS PARAMETERS: MAP *** To introduce the idea of functions as parameters, we will write two recursive functions that are structurally very similar.
		Notice the slight syntactic differences between this function and functions that are given a name.
	csis.pace.edu /~bergin/langprin/Tutorial.4 (1154 words)

	Recitation 3: Higher order functions
		is a so-called higher-order function: it is a function from functions to other values.
		We use the same rules as earlier: when a function is applied (called), we replace the call with the body of the function, with the argument variables (actually, variables appearing in the argument pattern) bound to the corresponding actual values.
		Functions that return other functions are so common in functional programming that ML provides a special syntax for them.
	www.cs.cornell.edu /courses/cs312/2003sp/lectures/rec03.htm (1204 words)

	On Introducing Higher Order Functions in ABEL - Kristoffersen, Dahl (ResearchIndex)
		Abstract: We discuss how the 1st order specification and programming language ABEL could be extended with higher order functions.
		...order equations should then not be modified as originally proposed in section 3.
		Several issues arise, related to subtyping, parameterization, strictness of generators and defined functions, and to the choice between lambda expressions and currying.
	citeseer.ist.psu.edu /kristoffersen98introducing.html (467 words)

	Higher-Order Theories of Consciousness
		And then in order to explain the absence of any kind of higher-order phenomenology, an inner-sense theorist only needs to maintain that our higher-order experiences are never themselves targeted by an inner-sense-organ which might produce third-order analog representations of them in turn.
		According to the sort of higher-order theory under discussion in this section, these senses, too, will need to have their outputs scanned to produce higher-order analog contents in order for them to become phenomenally conscious.
		It starts from the fact that the internal monitors postulated by such theories would need to have considerable computational complexity in order to generate the requisite higher-order experiences.
	setis.library.usyd.edu.au /stanford/entries/consciousness-higher (7324 words)

	Logic, Higher-order
		A common approach to describing the syntax of a higher-order logic is to introduce some kind of typing scheme.
		Using characteristic functions to represent predicates, this latter type is used as the type of predicates whose one argument is an individual.
		Identifying functions up to their graphs does, of course, treat functions extensionally, something that might be too strong in some applications.
	www.lix.polytechnique.fr /Labo/Dale.Miller/papers/AIencyclopedia (1791 words)

	Graham Hutton: Publications
		In functional programming, a popular approach to building recursive descent parsers is to model parsers as functions, and to define higher-order functions (or combinators) that implement grammar constructions such as sequencing, choice, and repetition.
		Functional programming is a style of programming in which the basic method of computation is the application of functions to arguments.
		More recent articles that explain the monadic approach to functional parsers are also available, in the form of a short JFP article, or as an extended technical report.
	www.cs.nott.ac.uk /Department/Staff/gmh/bib.html (3147 words)

	Quick Summary of Some Higher-Order Functions
		The "member" function is like "find" except that, if a match is found, it returns the entire target list starting at the match, rather than just the match itself.
		The "apply" function is similar to "funcall", but it expects the arguments to come in a list, rather than individually.
		The "remove-if" function returns a new list that was like the old list except that all elements satisfying a given predicate are removed.
	www.apl.jhu.edu /~hall/Lisp-Notes/Higher-Order.html (954 words)

	Vol 2 / Chapter 03 / Higher-Order Functions
		Next, we treat higher-order functions and their applications, such as mapping and folding, and we show how procedural control structures can be replaced by functional code.
		Thinking functionally, we can solve a range of problems far more elegantly than with the usual loop, which we often use first, without thinking, due to the lopsided introduction to programming to which most of us were subjected.
		Although functions are arguably the most important concept in mathematics, functions are not generally available as (first-class) values in all programming languages.
	www.mathconsult.ch /showroom/pubs/MathProg/htmls/2-03.htm (269 words)

	CS245 Lab 8: Higher Order Functions
		Write the functions for Question 1-4 in a file lab8.lisp in your simple-funcs project, and draw your answer to question 5 on paper and hand it in.
		Write a function "mapleaf" that applies a function to every "leaf" in such a list, and produces a list of the same structure containing the results.
		3) Write a function "compose" that returns the composition of two unary functions (the composition of f and g is a function that gives (f (g x)) for any x.
	www.haverford.edu /cmsc/course-pages/CMSC245/lab8.html (544 words)

	Higher order functions -
		If they are called with fewer than the required number of arguments, they return another higher order function, which now has the specified arguments bound as well.
		To cause this to be interpreted as a higher order function, the ambiguity must be resolved through using braces:
		First the positional placeholders are filled in (a higher numbered positional placeholder than the number of parameters results in a compile-time error).
	dev.perl.org /rfc/23.html (1169 words)

	COMP 205: Higher-Order Functions
		function) to illustrate the procedure that the interpreter follows in inferring the type of the function.
		All the functions above follow a similar pattern, and since we use this pattern so often, it might occur to us to abstract this pattern in the interests of code reuse.
		is a function, because it is applied to an argument.
	www.csc.liv.ac.uk /~grant/Teaching/COMP205/fHO.html (2028 words)

	ISSUE: Why no higher-order functions? from Shawn Vincent on 2002-01-14 (www-xml-query-comments@w3.org from January 2002)
		Most functional languages have higher-order functions (functions that can be stored in variables, and passed as arguments to other functions), and these provide a powerful mechanism for abstraction and expression that is nearly impossible to get otherwise.
		In summary, the lack of higher-order functions seems a crippling disability to XQuery, and there is much need, as demonstrated by use cases, the XQuery syntax itself, and the community.
		Also, witness the fact that shortly after XSLT was released, the need for higher-order functions was seen as useful enough to be integrated into Saxon as well as into the EXSLT spec.
	lists.w3.org /Archives/Public/www-xml-query-comments/2002Jan/0290.html (308 words)

	Higher Order Functions
		This poster presents our ideas for making higher-order functionality available in Ptolemy, and also points to some of the issues that need to be solved.
		The capability of components to instantiate other components, to receive and produce references to components as data items, to dynamically connect to or disconnect from other components, and to be parameterized by other components is what we collectively call 'higher-order functions' or sometimes 'higher-order components'.
		It is the key to a number of powerful modeling techniques, and also one of the main prerequisites for true component reuse.
	ptolemy.eecs.berkeley.edu /~ptII/conferences/01/abstracts/higherorder.htm (92 words)

	A Framework for Higher-Order Functions in C++
		Model function closures using C++ (closure accomplished by enclosing a function inside an object such that the local environment is captured by data members of the object).
		Basically, the problem is a call to a non-member function requires a stack pointer to store the actual arguments and the address of the function to be called whereas a member function invocation requires a stack pointer to store the arguments, the address of the member function, and the address of the receiver.
		This can be implemented with a data member that points to the function and a function call operator that passes its argument on to the function pointer.
	sern.ucalgary.ca /~hoangv/609.03/laufer.html (546 words)

	Higher-order functions
		As a simple example of how functions may be specialized w.r.t.\ higher-order values we consider the specialization of a version of the map function:
		As can be seen from the example the higher order elements (the lambda-abstraction and the application) have been removed and the residual program is entirely first-order.
		For interpreters using functions to represent environments this means that one may often get rid of the environment operations altogether when specializing the interpreter with respect to a program.
	www.diku.dk /users/torbenm/Similix/Similix/node28.html (127 words)

	2ndorder.html
		To study the second-order predicates provided in Prolog and higher-order functions and to construct other second-order predicates and higher-order functions.
		until(P,F,V) returns the result of applying the function F to the value the smallest number of times necessary to satisfy the predicate.
		Write a generic sort program, it should take a comparison function as a parameter.
	cs.wwc.edu /~aabyan/LABS/LogicProgramming/2ndorder.html (297 words)

	CS655 - Problem Set 1: Higher-Order Functions - Selected Answers
		Functions as first class objects - In Scheme, functions are first class objects which means we can do anything with them we can do with other kinds of objects.
		In C and C++, functions are not first class objects.
		The question is what it means --- we can produce a function in any universal language that has the same input-output (that is it produces the same result for the same parameters) behavior as any function we can write in Scheme.
	www.cs.virginia.edu /~evans/cs655/problem-sets/ps1-answers.html (1211 words)

	Higher-Order Correlation Functions and the FIRST Survey
		We incorporate the full dependence of the result for s_3 on Ømega_0 and, as well as the b_1 and b_2 terms in the bias expansion, in addition to the dependence on the index of the power spectrum and the redshift selection function.
		The moments of a two-dimensional distribution of sources on the sky can be explicitly obtained by integrating the corresponding projected k-space spectra (known from linear perturbation theory), weighted by appropriate window functions.
		These results will be compared to the observed values for the VLA FIRST survey, and the resulting constraints will be discussed.
	www.aas.org /publications/baas/v29n5/aas191/abs/S087005.html (153 words)

	Higher Order
		Higher order values are used in the same way as in functional programming.
		Higher order functions serve to hide part of the control.
		Higher order facilities of functional logic languages can be simulated in PROLOG too.
	lml.ls.fi.upm.es /~jjmoreno/ho.html (833 words)

	Homework 6: Accumulators; higher-order functions
		And of course, each function should still have a contract and purpose, and reasonable test cases.
		Now, generalize your function to not just sort ascending, and not just numbers: Have it accept a comparison function.
		(The order of the two lists, or of the elements in each of them, isn't important, but no two adjacent elements of the input should be in the same result list.)
	www.owlnet.rice.edu /~comp210/01fall/Assignments/hw06.shtml (785 words)

	Bibliography
		Linear recurrences of finite order with constant coefficients.
		In addition, probability generating functions are discussed and used to analyze problems in computer science.
		The use of the system is exemplified by analyzing a proof extract that computes the maximum segment sum of a list and a functional program that determines the minimum of a list via sorting.
	www.cs.unipr.it /purrs/Documentation/bibliography (1010 words)

	Striegnitz: Higher Order Functions and Partial Application in C++
		Polymorphic types, higher order functions, and partial application are common features in functional programming languages.
		Current approaches to integrate functional features into imperative languages are either based on the definition of a new language, or implemented as a runtime mechanism.
		In this paper we will present a method of how to integrate functional features into C++ without the need of runtime mechanisms, special preprocessors, or compilers.
	www.fz-juelich.de /zam/docs/autoren99/striegnitz (136 words)

	Macros and Higher Order Methods
		This document explores the types of higher order methods and how macros are special.
		Being able to pass methods in this way means methods can be treated as "first order" and the methods that act on methods are called "second order" or "higher order" methods.
		variable would also have to be passed into the body of the loop in order to update it.
	www.arcavia.com /kyle/Analysis/Macro.html (785 words)

Try your search on: Qwika (all wikis)

Topic: Higher-order function

Ads by Google

Related Topics

In the News (Sun 20 Dec 09)