Yoshihiko Futamura

Essence of generalized partial computation

Abstract Generalized partial computation (GPC) is a program optimization principle based on partial computation and theorem proving. Conventional partial computation methods (or partial evaluators) explicitly make use of only given parameter values to partially evaluate programs. However, GPC explicitly utilizes not only given values but also the following information: (1) logical structure of a program to be partially evaluated; (2) abstract data type of a programming language. The main purpose of this paper is to present comprehensible examples of GPC. Graphical notations, called GPC trees, are introduced to visibly describe GPC processes.

Partial Evaluation of Computation Process, Revisited

A1: After graduating from the Department of Mathematics at Hokkaido University (in Sapporo) in 1965, I engaged in developing an interpreter and a compiler for Lisp 1.5 at Hitachi Central Research Laboratory. The work was done based only on McCarthy’s manual [12]. When I was implementing the compiler, I realized that I was just looking at the interpreter written in the manual. Then the idea that a compiler could be generated from an interpreter came to me. I think this idea is fundamental. Other results such as partial evaluation and self-application follow the idea with good luck.

Program transformation system based on generalized partial computation

Generalized Partial Computation (GPC) is a program transformation method utilizing partial information about input data, abstract data types of auxiliary functions and the logical structure of a source program. GPC uses both an inference engine such as a theorem prover and a classical partial evaluator to optimize programs. Therefore, GPC is more powerful than classical partial evaluators but harder to implement and control. We have implemented an experimental GPC system called WSDFU (Waseda Simplify-Distribute-Fold-Unfold). This paper demonstrates the power of the program transformation system as well as its theorem prover and discusses some future works.

Automatic generation of efficient string matching algorithms by generalized partial computation

This paper shows that Generalized Partial Computation (GPC) can automatically generate efficient string matching algorithms. GPC is a program transformation method utilizing partial information about input data and auxiliary functions as well as the logical structure of a source program. GPC uses both a classical partial evaluator and an inference engine such as a theorem prover to optimize programs. First, we show that a Boyer-Moore (BM) type pattern matcher without the bad-character heuristic can be generated from a simple non-linear backward matcher by GPC. This sort of problems has already been discussed in the literature using offline partial evaluators. However, there was no proof that every generated matcher runs in the same way as the BM. In this paper we prove that the problem can be solved starting from a simple non-linear pattern matcher as a source program. We also prove that a Knuth-Morris-Pratt (KMP) type linear string matcher can be generated from a naive non-linear forward matcher by GPC.

WSDFU: program transformation system based on generalized partial computation

Generalized Partial Computation (GPC) is a program transformation method utilizing partial information about input data and auxiliary functions as well as the logical structure of a source program. GPC uses both an inference engine such as a theorem prover and a classical partial evaluator to optimize programs. Therefore, GPC is more powerful than classical partial evaluators but harder to implement and control. We have implemented an experimental GPC system called WSDFU (Waseda Simplify-Distribute-Fold-Unfold). This paper demonstrates the power of the program transformation system as well as its theorem prover and discusses some future works.

A New Termination Approach for Specialization

Well-quasi orderings, and particularly homeomorphic embedding, recently became popular to ensure the termination of program specialization and transformation techniques. In this paper, we present a termination approach called recursive condition approach to ensure the termination of online specializers. Just like some traditional approaches, recursive condition approach is also based on well-quasi orderings using homeomorphic embedding. However, instead of using the arguments of functions, the conditions invoking recursive calls are used. Because the recursive condition approach exploits the recursive conditions which, to some extent, contain some semantic information of original programs, we believe this approach is more adequate and can produce more efficient residual programs than traditional approaches using well-quasi orderings/homeomorphic embedding. Furthermore, we present an approach (called combined approach) that combines the advantages of the recursive condition approach and the traditional approach.

Partial evaluation and program transformation day

This special issue of New Generation Computing contains five, fully reviewed papers presented at the Partial Evaluation and Program Transformation Day held at Waseda University, Tokyo, November 15, 1999. This one-day colloquium featured talks and discussions on semantics-based program transformation with an emphasis on program specialization, generalized partial computation, and automatic program transformation. The contributions in this special issue represent state-of-the-art research ranging from theoretical works to practical studies, and across different programming language paradigms (functional, logic, object-oriented). They are arranged alphabetically. Here is a brief summary of the contributions:

Automatic Generation of Very Efficient Programs by Generalized Partial Computation

Generalized Partial Computation (GPC) is a program transformation method utilizing partial information about input data, properties of auxiliary functions and the logical structure of a source program. GPC uses both an inference engine such as a theorem prover and a classical partial evaluator to optimize programs. Therefore, GPC is more powerful than classical partial evaluators but harder to implement and control. We have implemented an experimental GPC system called WSDFU (Waseda Simplify-Distribute-Fold-Unfold). This paper discusses the power of the program transformation system, its theorem prover and future works.

Automatic generation of a boyer-moore lype pattern matcher by generalized partial computation

The pmrpose of this paper h to show that we c m generate emdent string matching algorithms nutomalicsiiy by Generalized Partial Computation (GPO. GPC is P program transformstion method utilizing partial information about input data m d auriliary functions as weU a6 the logical s t r ~ ~ h l r e of P source p-m. GPC uses both I rlsrrieal partial evaluator and an inference engine such ss thmnm prover to optimim prognmr. Here, we show that a Boyer-Moore type pattern matcher dthout the badshameter heuristic can be generated from a naive mn-tinesr backward matcher by GPC. This SOOR of problem has dresdy been discussed in P literature using otl-liae partial m l u ~ t o r . However, 10 the but d o u r knowledge, t h h is the flm paper to prove that every generated matcher mni in the Iame way as the BM. Here we will show with a proof that the problem e m be solved starting from a simple and naive psnem matcher 81 a source program. We a b show with a proof that a KMP type linear slring matcher can be generated from P naive non-linear fomsrd matcher by GPC.

Abstraction from constructors and functional constructors and their applications

Structures using constructors are of ordinary use in functional programming to represent data structures of unbound size. Lack of associativity of constructors, however, hinders program analyses or efficient executions. This paper describes ideas of abstraction toward constructors, and similarly abstraction from constructing functions, which we call functional constructors. We demonstrate our ideas making program analyses easier and enable transformation to efficient execution.