Where results make sense
About us   |   Why use us?   |   Reviews   |   PR   |   Contact us  

Topic: Funarg problem

Related Topics

In the News (Wed 22 May 19)

  Funarg problem - Wikipedia, the free encyclopedia
The downwards funarg problem arises from passing a function as a parameter to another function call.
The upwards funarg problem arises because the funarg may refer to the local state of a function after that function has returned.
The downwards funarg problem complicates the efficient compilation of tail recursion and code written in continuation passing style.
en.wikipedia.org /wiki/Funarg_problem   (692 words)

 RE: What's so cool about Scheme?
For example, at http://www.stanford.edu/class/cs242/readings/vocabulary.html, it says: "funarg problem - The failure of traditional stack-based implementations of procedure calls in the presence of "first-class" functions (functions that can be passed as procedure parameters and returned as procedure results).
Upwards funarg problem: the problem of returning a function as a procedure result; requires allocating activation records on the heap and returing a closure containing a pointer to code and a pointer to the enclosing activation record.
Downwards funarg problem: the problem of passing a function as a procedure parameter; requires a tree structure for activation records." It's definitions like this that led to my misunderstanding.
people.csail.mit.edu /gregs/ll1-discuss-archive-html/msg03278.html   (585 words)

 CS242: Vocabulary
: the problem of returning a function as a procedure result; requires allocating activation records on the heap and returing a closure containing a pointer to code and a pointer to the enclosing activation record.
: the problem of passing a function as a procedure parameter; requires a tree structure for activation records.
The problem of determining whether a given program halts when executed on a given input.
www.stanford.edu /class/cs242/readings/vocabulary.html   (1468 words)

 [No title]
A funarg is a list beginning with the atomic symbol funarg, as you might expect, and containing a function and a binding context pointer.
When it generates a funarg, it puts in the funarg the functional expression it was given and a binding context pointer designating the binding environment current at the time *function was called.
Funargs generated by *function are intended for use as functional arguments and cannot be returned as values of functional applications.
zane.brouhaha.com /~healyzh/doc/lisp.doc.txt   (17440 words)

 [No title]
The Problem with Stacks In C or FORTRAN, all procedure calls can be stack allocated.
This remains true even in a language such as Pascal where procedure definitions can be nested, so long as one does not allow procedures to be returned as the result of procedures.
The important point of this example is that a value referring to "g" has greater extent than the function "f" that creates it, so the calls to "f" and "g" cannot be stack allocated.
www.cs.berkeley.edu /~fateman/264/papers/aiken-CPS.txt   (1981 words)

 Weblogs Forum - Macros and Type-Systems
I don't have any definition other than the wikipedia one to work with, which is specifically: "The upwards funarg problem is the problem of passing a function as a value returned "upwards" from a function call".
If you google for "the upward funarg problem" you'll find that the first hit points out that it means to be able to return functions (or procedures) as values, which isn't fully supported by your idea.
These are problems I encountered trying to implement certain libraries in a way which made sense to me in C++ but I was too limited by the language to go further than a certain point.
www.artima.com /forums/flat.jsp?forum=106&thread=129881&start=15&msRange=15   (4686 words)

 funarg problem - the "upwards funarg" problem.
As I have noted in previous posts, this is an instance of the "upwards funarg" problem.
The key is to note that the prefix acts as a lexically apparent binding for a URI over which a child element closes whenever it comprises a name which is qualified by the given prefix.
When I looked further, I noted that for which the prorgammers's manual was published in 1961 and, as described in (http://www8.informatik.uni-erlangen.de/html/lisp/mcc91.html) the initial work on it - including the funarg problem is described in memos from the MIT AI-Lab from as early as 1959.
www.stylusstudio.com /xmldev/199901/post80690.html   (526 words)

 ACM Sigplan Notices 27, 3 (Mar 1992), 24-34.
A problem which occurs in any language which offers both functional arguments and side-effects, however, is making sure that the object being side-effected is "the" object, rather than a copy of it.
In particular, when one creates multiple funargs which share the same free variable, and one or both of the funargs side-effect this variable, it is important that the side-effect be visible to all of the funargs.
A funarg environment need only retain the bindings of the variables free in the function being passed, so the funarg environment could be a simple vector of these variable values.
home.pipeline.com /~hbaker1/LazyAlloc.html   (12887 words)

 lambda calculus -
The question of whether two lambda calculus expressions are equivalent cannot be solved by a general algorithm, and this was the first question, even before the halting problem, for which undecidability could be proved.
Rather, they are based on the syntax of the lambda calculus, together with a misunderstanding of the notion of binding and substitution in the lambda calculus.
In Lisp terminology, this is known as the Funarg problem.
www.infotechloco.com /Inf-Computer-Topics-L---M/Lambda-calculus.html   (2185 words)

 ACM OOPS Messenger 4, 4 (Oct 1993), 2-27
Functional arrays are known to have performance problems, because a succession of single-element updates may convert a problem of linear complexity into one of quadratic complexity [Bloss89].
Abstract data types cause problems because they are supposed to be opaque; i.e., equivalence should depend only upon the identity of the abstract data type itself, and not upon whatever representation is currently being used to implement it [Guttag77].
Regardless of their theoretical problems, recursive data types are handled in the following way by Pascal, C, Ada, etc. The programmer first declares that the recursive type is a type (we have purposely fuzzed the distinction between "type" and "type name"), but gives no details; then he uses the type to construct another type.
home.pipeline.com /~hbaker1/ObjectIdentity.html   (15312 words)

 The Early History of Smalltalk
One of the ways to solve the "funarg problem" of LiSP is to associate the proper global tate link with expressions and functions that are to be evaluted later so that the free variables referenced are the ones that were actually implied by the static form of the language.
The other problem that had to be taken care of was object-pointer integrity (and this is where I had failed in the FLEX machine to come up with a good enough solution).
Then there were a host of problems that were really outside the scope of Simula's goals: having to do with various kinds of modeling and inferencing that were of interest in the world of artifical intelligence.
gagne.homedns.org /~tgagne/contrib/EarlyHistoryST.html   (20062 words)

 Lambda calculus Summary
Lambda calculus can be used to cleanly define what a computable function is. The question of whether two lambda calculus expressions are equivalent cannot be solved by a general algorithm, and this was the first question, even before the halting problem, for which undecidability could be proved.
Barendregt, Henk, The lambda calculus, its syntax and semantics, North-Holland (1984), is the comprehensive reference on the (untyped) lambda calculus; see also the paper Introduction to Lambda Calculus.
Church, Alonzo, An unsolvable problem of elementary number theory, American Journal of Mathematics, 58 (1936), pp.
www.bookrags.com /Lambda_calculus   (2877 words)

 Emergent Technologies Inc. -- LISP Machine Progress Report   (Site not responding. Last check: 2007-10-12)
Another problem with the PDP-10 LISP implementation is the small address space of the PDP-10 processor.
This problem is further compounded by the inefficiency of the information coding of compiled Lisp code; compilers for the PDP-10 produce only a limited subset of the large instruction set made available by the hardware, and usually make inefficient use of the addressing modes and fields provided.
Some problems are best attacked using data structures organized in the list-processing style of Lisp, and some are best attacked using the array-processing style of FORTRAN.
home.comcast.net /~prunesquallor/memo444.htm   (10596 words)

 AI Newsletter
Brown ends by setting a problem to choose a bug, characterise it, and then write a short story with the bug as its twist.
He compared how novice and expert economists solve problems, and developed models of each type of reasoning and a theory for how novices reorganise their memory as they gain expertise.
Problem 16-6 (by Richard Brown) in Chapter 17, Problems to think about, from Artificial Intelligence (1st edition) by Patrick Winston, 1977.
www.ainewsletter.com /newsletters/aix_0506.htm   (6223 words)

 [No title]
The problem with the latter is that they are so general that it is difficult for the compiler to optimize anything; also, they do not completely solve the problem of choosing between static and dynamic binding.
One is the well-known "FUNARG" problem [Moses 70]; the essence of this problem is that lexical scoping is desired for functional arguments.
One problem with (feature of??) the lowering mechanism is that any procedure, not just one controlling the behavior of a data type, can use the lowering primitive and so defeat the data type functions.
www.cs.unm.edu /~williams/cs491/lambda.txt   (12444 words)

 A Real-Time Garbage Collector Based on the Lifetimes of Objects
We were led to work on the garbage collection problem because of the performance needs of applications in artificial intelligence (Al).
A problem with our algorithm is that it introduces fragmentation, since partially filled regions will waste some space, lowering the average density of accessible objects.
However, just like the fragmentation problem in paging systems, the region size should be chosen so that fragmentation is not a significant source of inefficiency.
web.media.mit.edu /~lieber/Lieberary/GC/Realtime/Realtime.html   (8598 words)

 Amazon.com: "funarg problem": Key Phrase page   (Site not responding. Last check: 2007-10-12)
See all pages with references to funarg problem.
The need for deep binding is sometimes referred to as the funarg problem in Lisp.
The well-known FUNARG problem is a consequence of this strategy and palliatives like closures are not easy to put in practice.
www.amazon.com /phrase/funarg-problem   (452 words)

 xml-dev - the "upwards funarg" problem.
Is it a problem to associate prefixes with names in the DOM?
if the term means nothing to you, that note will explain enough for you to recognize the problem in the prefix<->URI bindings which may appear in DOM elements.
The comp.compilers note also makes the point that, although this article constituted a publication milestone, the issue was addressed in implmentations which dated much earlier.
lists.xml.org /archives/xml-dev/199901/msg00698.html   (468 words)

 References   (Site not responding. Last check: 2007-10-12)
Moses, Joel (1970) The function of FUNCTION in LISP or why the FUNARG problem should be called the environment problem", M.I.T. Artificial Intelligence Memo 199, Cambridge, Mass.
Thus they were on the fourth floor, and I was in the first floor computer room exercising LISP and speaking into a microphone.
The problem chosen was to determine whether a first order differential equation of the form was exact by testing whether, which also involved some primitive algebraic simplification.
www-formal.stanford.edu /jmc/history/lisp/node7.html   (1116 words)

 Monograph: 3 Reality Directed Methods   (Site not responding. Last check: 2007-10-12)
Early methods started with an informal strategy to solve the problem and used this as the source of objects etc.
His case study of the development of ideas and models concerned with a single formula about polyhedra over a 100 year period indicates that proposing a mathematical model is an invitation to search for counter examples as well as proofs.
Incremental development means that the DFD can have several threads of execution running at one time as long as the system, model, and specification are modularized so that changes made by one thread do not disrupt the rest.
www.csci.csusb.edu /dick/monograph/01_3.html   (6353 words)

 Readings: Theory of Computation
A collection of fundamental papers by Gödel, Church, Post, etc. The papers that have direct bearing on the Miser Project are cited individually in one of the appropriate annotated bibliographies.
The FUNARG problem is one that we simply will not have and will not tolerate in Miser.
The Frame Problem in the Situation Calculus: A Simple Solution (Sometimes) and a Completeness Result for Goal Regression, R.
nfocentrale.net /miser/readings/theory.htm   (1816 words)

 CSE 635   (Site not responding. Last check: 2007-10-12)
In effect, you can discuss the problems but not the solutions.
Remember that there are many different ways to solve the same problem; even solutions with the same central idea can be formulated in many different ways.
Scheme: functions as values, the funarg problem, closures l2
www.cs.sunysb.edu /~cse307/Spring02   (1290 words)

 10 on Thu May 9 12:35:43 PDT 2002   (Site not responding. Last check: 2007-10-12)
Object-oriented programming languages make it easy and safe to have local (class-wide) variables shared between several functions.
No problem with static links etc since the variables in the subprogram are resolved by the compiler.
However this is not unlike the FUNARG problem in LISP (chapter 13)...
www.csci.csusb.edu /dick/cs320/sebesta/10.html   (995 words)

 Publication list for Erik Sandewall 1967-2006   (Site not responding. Last check: 2007-10-12)
Erik Sandewall: An Approach to the Frame Problem, and its Implementation.
The Frame Problem in Artificial Intelligence [Frank M. Brown, Editor], pp.
Erik Sandewall: The Range of Applicability of Nonmonotonic Logics for the Inertia Problem.
www.ida.liu.se /ext/caisor/archive/publist/Sandewall,Erik.html   (1598 words)

 History of LISP — Software Collection Committee
"Abstract: The problem of the use of two levels of storage for programs is explored in the context of a LISP system which uses core memory as a buffer for a large virtual memory stored on a drum.
Discusses BBN LISP on the SDS 940, which had 16K of 24-bit core memory and 1M words of drum memory (17 milliseconds average access time).
The problem of retention (by closures) of the dynamic function-definition environment in the presence of special variables was never completely solved until spaghetti stacks were invented." [Steele and Gabriel 1993]
community.computerhistory.org /scc/projects/LISP   (8943 words)

 Global Variables   (Site not responding. Last check: 2007-10-12)
In either case parameters to the function are bound to arguments provided by the caller.
The infamous funarg problem (See Google) illustrates some of the disadvantages of dynamic scoping.
I think that the following history is correct.
www.cap-lore.com /Languages/Global.html   (546 words)

Try your search on: Qwika (all wikis)

  About us   |   Why use us?   |   Reviews   |   Press   |   Contact us  
Copyright © 2005-2007 www.factbites.com Usage implies agreement with terms.