
	Where results make sense

Topic: Eager evaluation

Related Topics

Lazy evaluation

Functional programming

Programming paradigm

Imperative programming

Declarative programming

Procedural programming

Lambda calculus

In the News (Thu 16 Feb 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	Lazy evaluation - Wikipedia, the free encyclopedia
		Besides performance increases, the most important benefit of lazy evaluation is that it allows one to construct an infinite data structure.
		Minimal evaluation (also known as short circuit evaluation) is an evaluation strategy in which an expression is only evaluated until the point where its final value is known.
		When using delayed evaluation, an expression is not evaluated as soon as it gets bound to a variable, but when the evaluator is forced to produce the expression's value.
	en.wikipedia.org /wiki/Lazy_evaluation (692 words)

	Eager evaluation - Wikipedia, the free encyclopedia
		Eager evaluation is the evaluation model in most traditional programming languages.
		In eager evaluation an expression is evaluated as soon as it gets bound to a variable.
		However, in more sophisticated programming languages, the low-level optimisation of forced eager evaluation is found to be disadvantageous over lazy evaluation.
	en.wikipedia.org /wiki/Eager_evaluation (132 words)

	eager evaluation - FOLDOC Definition (Site not responding. Last check: 2007-10-21)
		Any evaluation strategy where evaluation of some or all function arguments is started before their value is required.
		The term "speculative evaluation" is very close in meaning to eager evaluation but is applied mostly to parallel architectures whereas eager evaluation is used of both sequential and parallel evaluators.
		Eager evaluation does not specify exactly when argument evaluation takes place - it might be done fully speculatively (all redexes in the program reduced in parallel) or may be done by the caller just before the function is entered.
	www.nightflight.com /foldoc-bin/foldoc.cgi?eager+evaluation (188 words)

	Computer Evaluation (Site not responding. Last check: 2007-10-21)
		The evaluation function is typically designed to be fast and accuracy is not a concern (therefore heuristic); the function looks only at the current position and does not explore possible moves (therefore static).
		The formation evaluation problem is a matter of two urinals: #Knowing the lower limits for porosity, permeability and water saturation that work for a particular formation or pay zone, in a particular geographic area, in a particular economic climate.
		Often the heuristic evaluation is conducted in the context of use cases (typical user tasks), to provide feedback to the site’s developers on the extent to which the interface is likely to be compatible with the intended users’ needs and preferences.
	www.wwwtln.com /finance/49/computer-evaluation.html (1744 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		Eager and lazy evaluation ------------------------- In a function call such as f(e), one may evaluate the argument expression e eagerly, to obtain a value v before evaluating the function body.
		Alternatively, one might evaluate e lazily, that is, postpone evaluation of e until we have seen that the value of e is really needed.
		That is because the interpreter (function eval in fun/fun.sml) evaluates the argument expressions of a function before evaluating the function body, and because the meta-language SML is strict.
	www.dina.kvl.dk /~sestoft/ppif2001/notes05.txt (3435 words)

	Lecture 6: Eager vs. Lazy Evaluation. Higher-Order Functions (Site not responding. Last check: 2007-10-21)
		The evaluation strategy in which function arguments are evaluated before the function call is made is known as an "eager" evaluation.
		Eager evaluation is used by most well-known modern programming languages, and it might seem so natural that we don't even consider the possibility of alternative evaluation strategies.
		Function definitions are evaluated by creating an internal representation for them, without actually executing their body (the body is executed only at the time of a function call, after all actual function arguments have been provided).
	www.cs.cornell.edu /courses/cs312/2004fa/lectures/lecture6.htm (1389 words)

	Eager evaluation -- Facts, Info, and Encyclopedia article (Site not responding. Last check: 2007-10-21)
		Eager evaluation is the (An appraisal of the value of something) evaluation model in most traditional ((computer science) a language designed for programming computers) programming languages.
		In eager evaluation an (Expression without words) expression is evaluated as soon as it gets bound to a (A quantity that can assume any of a set of values) variable.
		However, in more sophisticated programming languages, the low-level (The act of rendering optimal) optimisation of forced eager evaluation is found to be disadvantageous over (Click link for more info and facts about lazy evaluation) lazy evaluation.
	www.absoluteastronomy.com /encyclopedia/e/ea/eager_evaluation.htm (183 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		Eager evaluation is useful for immediately showing all the effects of any change.
		The way that it supports eager evaluation is that the mark phase keeps a list of constraints that it marks out_of_date and which have no successors.
		In both the eager evaluation case and the lazy evaluation case in which constraints can be marked "eager", the constraint solver needs to allow an explicit call to be made to it to bring constraints up-to-date.
	www.cs.utk.edu /~bvz/cs594/notes/constraint-implementation.html (3322 words)

	Berkeley DB XML: XmlQueryContext::setEvaluationType (Site not responding. Last check: 2007-10-21)
		Eager evaluation means that the whole query is executed and its resultant values derived and stored in-memory before evaluation of the query is completed.
		Lazy evaluation means that minimal processing is performed before the query is completed, and the remaining processing is deferred until the result set is enumerated.
		Minimal processing is performed before evaluation of the query is completed, and the remaining processing is deferred until the result set is enumerated.
	www.sleepycat.com /xmldocs/api_cxx/XmlQueryContext_setEvaluationType.html (152 words)

	[No title]
		In lazy evaluation, bindings are used for sort of textual references -- it is only for avoiding writing an expression twice, but the associated computation is done twice anyway.
		Consider evaluating this expression: {with {x {/ 1 0}} {+ 1 2}} So the summary is: as long as the initial program is correct, both evaluation regimens will produce the same results.
		Also, there are some cases where eager evaluation runs into a run-time problem which does not happen in a lazy evaluator because the expression is not used.
	www.ccs.neu.edu /course/csu660/lec08.txt (960 words)

	Medical Evaluations -- Recommendations and Resources (Site not responding. Last check: 2007-10-21)
		Performance evaluation is a term from the field of language testing and psychometrics.
		While performance evaluation has been successful in evaluating reading comprehension performance, difficulties arise in evaluating speaking, listening and writing skills which are weightier aspects of the goal of language learning, communicative competence.
		As a result, a balance of performance evaluation and competency evaluation is often called for by language teachers.
	www.becomingapediatrician.com /health/93/medical-evaluations.html (1876 words)

	Clean Language Report 2.0/chapter/section (Site not responding. Last check: 2007-10-21)
		Evaluation of a function will happen in the following order: patterns, guard, expressions in a strict let before expression, root expression (see also 3.1).
		So, lazy evaluation gives a notational freedom (no worrying about what is computed when) but it might cost space as well as time.
		The order of evaluation of expressions in a function body can also be changed from lazy to strict by using a strict let-before expression (see 3.5.4).
	www.cs.ru.nl /~clean/CleanExtra/report20/chapter10/s101.html (1020 words)

	CSC 330 Lecture Notes Week 10
		This form of evaluation is eager in the sense that it evaluates all arguments, even if their evaluation may not be necessary.
		The basic idea of lazy evaluation is not to evaluate an argument until it is actually used in the body of the function.
		While the result of the computation is obviously the same as with eager evaluation (it must be, in fact!), it is important to understand the order in which evaluations took place.
	www.csc.calpoly.edu /~gfisher/classes/330/lectures/10.html (1805 words)

	Research Highlights - More Haste Less Speed
		We have shown, we believe for the first time, that lazy evaluation of functional programming languages is strictly more powerful than eager evaluation, as measured by the asymptotic complexity of evaluating certain programs.
		It turns out to be relatively straightforward to estimate the execution time of functional programs under an eager evaluation strategy, but it is hard to reason about the value produced: applying a constant function to a non-terminating expression leads to a non-terminating program, rather than returning the constant.
		Languages such as Haskell use lazy evaluation, which applies functions to arguments whose evaluation is postponed until the first (but only the first) time their values are needed.
	web.comlab.ox.ac.uk /oucl/work/geraint.jones/morehaste.html (416 words)

	Recitation 8: Lazy/Eager evaluation, thunks (Site not responding. Last check: 2007-10-21)
		However, lazy evaluation gets into trouble if a parameter is used repeatedly in a function, and the actual value is needed multiple times.
		Lazy evaluation also complicates expressions with side effects (especially when caching is involved).
		Eager evaluation is more popular than lazy evaluation in modern languages.
	www.cs.cornell.edu /courses/cs312/2004fa/lectures/rec08.htm (662 words)

	Expert About ea:Eager
		EAGER is the European algebraic geometry research training network, which is organized into 12 geographical nodes.
		EAGER is the acronym for the European Algebraic Geometry research network.
		HOWARD, John Eager, (father of Benjamin Chew Howard), a Delegate and a Senator from Maryland; born at ‘Belvedere,’ near Baltimore, Md....
	expertsite.biz /dir/ea/eager.htm (1075 words)

	Computer Science 68, Notes 01-27 (Site not responding. Last check: 2007-10-21)
		In theory, laziness is "optimal" when compared to eager or evaluate-by-need; in practice, there's some extra overhead to handle the memoization, so real-world eager languages may still be a bit faster than real-world lazy languages on most programs.
		The problem with the "exists(t x) e" expression, and the evaluation rule given above, is that it is hard to implement: the rule suggests that an interpreter has to guess a value v, substitute v in for x in the expression e, and then check to see that the result evaluates to true.
		Almost all the evaluation rules and type checking rules for jLogic are exactly the same as the rules for j2 (except that you have to write "p" in many places where an "e" occurs in j2, which I kept forgetting in class).
	www.cs.dartmouth.edu /~cs68/04w/notes-01-28.html (2410 words)

	[TYPES] Combining lazy and eager evaluation of terms
		Thus every subterm is always fully evaluated eventually, but certain recursive terms are supported which would, in an eager language, either be disallowed or result in access to uninitialized data.
		Recent papers on Java class loaders in purely eager environments indicate that this process is somewhat contrived in the absence of general support for thunked evaluation.
		This unboxing process becomes tricky with function closures; in the general case, two versions of a closure's environment and code pointer need to be kept around to support its evaluation in both both thunked and unboxed contexts, and in some cases only the thunked version may be safely invoked.
	lists.seas.upenn.edu /pipermail/types-list/2004/000340.html (773 words)

	[No title] (Site not responding. Last check: 2007-10-21)
		by evaluating the expression that is obtained of the definition of
		Eager evaluation would now lead to an undefined value for the third operand, when
		Lazy evaluation causes no problems, when the value of the first operand is used to determine, whether it is the second or the third operand that is needed.
	www.cs.tut.fi /~okp/slk01/luennot/week38.html (654 words)

	Expressions: Operators
		Associativity describes the order of evaluation of a series of operators of the same precedence, but does not describe the order in which the two sub-expressions or operands of a particular operator should be evaluated.
		Lazy evaluation is not performing part of a computation unless or until we really need to.
		In this context, it means only evaluating that part of a (boolean) expression that is enough to decide the value of the whole.
	www.cs.man.ac.uk /~pjj/cs2111/ho/node2.html (1518 words)

	lazy_eager
		The evaluation strategies, are differentiated according to the method of passing arguments to functions.
		Eager evaluation is used to implement strict functions.
		This means for instance that an expression being a function argument is not evaluated at the point of call (as is usually the case with traditional languages and non-lazy functional ones).
	www.cse.iitd.ernet.in /~saroj/lazy_eager.htm (5883 words)

	Combining lazy and eager evaluation of terms \| Lambda the Ultimate
		In an attempt to combine some of the benefits of lazy and eager evaluation, I have implemented a language with an evaluation strategy which is strict with respect to divergence, but performs lazy evaluation on certain intermediate subterms to allow a more expressive use of recursion.
		Dominic: That approach to Y works under lenient evaluation, and is actually the literal translation I use to evaluate recursive terms.
		In a lenient language, all subterms are always evaluated to ground values "eventually", even when their values are not demanded.
	lambda-the-ultimate.org /node/view/243 (758 words)

	Comp210 Lecture
		The opposite of lazy evaluation is "eager" evaluation.
		That is the lazy evaluation should apply only the first time a list node is requested, it should be eager after that.
		The use of the Decorator design pattern to implement lazy evaluation in Java was first puublished in 2000 by Dr. Nguyen and Dr. Wong.
	www.owlnet.rice.edu /~comp210/02fall/Lectures/Lecture42 (1233 words)

	Berkeley DB: XmlQueryContext::setEvaluationType
		Eager evaluation means that the whole query is executed and its resultant values derived and stored in-memory before the call to XmlContainer::queryWithXPath returns.
		Lazy evaluation means that minimal processing is performed before XmlContainer::queryWithXPath returns, and the remaining processing is deferred until the result set is enumerated.
		Minimal processing is performed before XmlContainer::queryWithXPath returns, and the remaining processing is deferred until the result set is enumerated.
	sunsite2.berkeley.edu /~gmills/dbxml_docs/api_cxx/xmlquerycontext_setevaluationtype.html (123 words)

	Evaluation Strategy (Site not responding. Last check: 2007-10-21)
		A module with this evaluation strategy asks the user for values for the facts in the import interface, and queries for values of facts in the submodules' interface only if necessary.
		Given a query to an eager module the following actions are done: it asks the user for the value of all the imported facts of the module, and it also asks for the values of all the exported facts of its submodules.
		This kind of evaluation strategy asks questions in the same form as the eager evaluation strategy, but no actions are made at deductive level.
	www.iiia.csic.es /~puyol/publications/math/node19.html (232 words)

	[TYPES] Combining lazy and eager evaluation of terms
		My recommendation is to read the paper "Compilation of extended recursion in call-by-value functional languages" which can be found here: http://pauillac.inria.fr/~hirschow/ Their approach in short: They only do call-by-value, no other evaluation order is used.
		Thus every subterm is always fully > evaluated eventually, but certain recursive terms are supported which > would, in an eager language, either be disallowed or result in access to > uninitialized data.
		Recent papers on > Java class loaders in purely eager environments indicate that this > process is somewhat contrived in the absence of general support for > thunked evaluation.
	lists.seas.upenn.edu /pipermail/types-list/2004/000347.html (884 words)

	Qexo
		An expression is only evaluated when result needed.
		Qexo's eager evaluation maps XQuery program structure more directly into VM state.
		Evaluate arguments and save them and called function in well-known location.
	per.bothner.com /papers/Qexo04/talk.html (338 words)

Try your search on: Qwika (all wikis)