A termination preserving supercompiler for a call-by-value language sometimes fails to remove intermediate structures that a supercompiler for a call-by-name language would remove. This discrepancy in power stems from the fact that many function bodies are either non-linear in use of an important variable or often start with a pattern match on their first argument and are therefore not strict in all their arguments. As a consequence, intermediate structures are left in the output program, making it slower. We present a revised supercompilation algorithm for a call-by-value language that propagates let-bindings into case-branches and uses termination analysis to remove dead code. This allows the algorithm to remove all intermediate structures for common examples where previous algorithms for call-by-value languages had to leave the intermediate structures in place.

In wanting to improve program speed one idea is to generalize the concept of executing a program in a context to the concept of executing a program in a partial context. The result of such a execution is a new program that when executed in a context matching the partial context will behave as the original program would. The new program will run faster since as much execution that was possible with respect to the partial context has been done and the result of it built into the new program. We will call such a execution for partial execution. Partial execution may be done for any programming paradigm. When it is done for functional languages we call it partial evaluation. The thesis now is that a certain method of partial execution is advantageous. To support the thesis the method is precisely stated for call-by-name functional languages along with arguments of its appropriateness. Then measurements and examples from a successful implementation of the method gives further support. Final...

It is the business of the computational linguist to give an account of how language is used — that is, to explain how it is that a physically-realizable system could ever give rise to the diversity of language behaviors that ordinary people exhibit. At least, this is

Recursion in grammar and performance In the last 50 years of cognitive science, linguistic theory has proposed more and more articulated structures, while computer science has shown that simpler, flatter structures are more easily processed. If we are interested in adequate models of human linguistic abilities, models that explain the very rapid and accurate human recognition and production of ordinary fluent speech, it seems we need to come to some appropriate understandingoftherelationshipbetweentheseapparently opposing pressures for more and less structure. Here we show how the apparent conflict disappears when it is considered more carefully. Even when we regard the linguists ’ project as a psychological one, there is no pressure for linguists to abandon their rather deep structures in order to account for our easy production and recognition of fluent speech. The deeper, more recursive structures reflect insights into similarities among linguistic constituents and operations, but a processor can compute exactly these structures without the extra effort that deeper analyses might seem to require. To show how this works, we