We have developed several partial evaluation systems. Firstly, we developed the partial evaluator INDY for functional logic programs. It is implemented in Prolog and considers an abstract syntax based on simple rewrite rules. It follows the narrowing-driven approach to partial evaluation as presented in [AFV96, AFV98, AV02].
We have also developed an online partial evaluator for the multi-paradigm language Curry (indeed, this is the first purely declarative partial evaluator for functional logic programs). The partial evaluator is written in Curry itself and considers arbitrary Curry programs (including higher-order, several built-in functions, concurrent constraints, etc). This partial evaluation tool has been integrated into the PAKCS compiler for Curry. The partial evaluator follows the ideas presented in [AHV00, AHV01, AHV02].
Recently, we have implemented an offline version of the previous partial evaluator. The new system, together with a description of several benchmarks, is available here.
A more
technical description appears in
[RSV05].
We have developed a prototype implementation (approx. 2000 lines of code) of a partial deduction system for Prolog programs which follows the offline approach. Basically, we apply a quasi-termination analysis (based on size-change graphs) and, then, annotate the source program so that potential loops are avoided by generalizing dangerous arguments of selected atoms at partial evaluation time.
More information can be found
here.
You can also read
this
paper.
We have developed an automatic technique for the partial inversion of first-order functions. Here, "partial" means that not all input parameters become output parameters after inversion, but some of the inputs may remain as such. This is useful in some cases because the original function needs not be injective in order to produce a confluent inverse function.
More information can be found
here.
You can also read
this
paper.
In order to asses the effectiveness of the partial evaluation process, we have developed a source-level abstract profiler for Curry programs. It is "abstract" in the sense that it measures the number of basic operations performed during a computation rather than actual execution times (e.g., the number of function unfoldings, pattern matchings, or applications). A complete description of the profiler can be found in [AV01].
Following a similar purpose, we have developed a cost-augmented
partial evaluator. It is available
here.
This system is an extended version of the
partial evaluator
for the multi-paradigm language
Curry.
The original narrowing-driven
partial evaluator is enhanced with the computation of
abstract costs (similarly to the profiler above).
In order to ease the analysis of the results,
we also incorporate a simple speedup analysis
which allows us to determine the improvement achieved by
the specialization process.
The original ideas about measuring the effectiveness of partial
evaluation can be found in
[AAV00].
The formalization of the cost-augmented partial evaluator for programs
in the flat representation is here:
[Vid02,
Vid04].
By exploting the similarities between (forward) slicing and (online) partial evaluation, we developed a forward slicing tool for the multi-paradigm language Curry. The (forward) slicing tool has been implemented by adapting an existing partial evaluator for Curry programs. It required a small implementation effort, i.e., only the underlying meta-interpreter needed significant changes.
The forward slicing scheme is described in
[SV07].
The implemented tool can be downloaded from
this link.
We developed a transformation system SYNTH for functional logic programs based on the fold/unfold methodology. The current version of SYNTH can be found here (it is maintained by Ginés Moreno).
We have also developed a list-processing optimizer for Curry. The prototype is written in Curry.