scholarly journals Efficient Compilation of Functional Languages by Program Transformation

1998 ◽  
Vol 14 ◽  
pp. 287-300
Author(s):  
André Santos
Keyword(s):  
Program Transformation ◽  
Functional Languages

scholarly journals Set constraints for destructive array update optimization

2001 ◽  
Vol 11 (3) ◽  
pp. 319-346 ◽  
Author(s):  
MITCHELL WAND ◽  
WILLIAM D. CLINGER
Keyword(s):  
Polynomial Time ◽  
Program Transformation ◽  
Operational Semantics ◽  
Functional Languages ◽  
Small Step ◽  
Set Constraints ◽  
Correct Program

Destructive array update optimization is critical for writing scientific codes in functional languages. We present set constraints for an interprocedural update optimization that runs in polynomial time. This is a multi-pass optimization, involving interprocedural flow analyses for aliasing and liveness. We characterize and prove the soundness of these analyses using small-step operational semantics. We also prove that any sound liveness analysis induces a correct program transformation.

Manipulating accumulative functions by swapping call-time and return-time computations

2012 ◽  
Vol 22 (3) ◽  
pp. 275-299
Author(s):  
AKIMASA MORIHATA ◽  
KAZUHIKO KAKEHI ◽  
ZHENJIANG HU ◽  
MASATO TAKEICHI
Keyword(s):  
Program Transformation ◽  
Return Time ◽  
Higher Order ◽  
Functional Languages ◽  
Recursive Functions ◽  
Program Inversion

AbstractFunctional languages are suitable for transformational developments of programs. However, accumulative functions, or in particular tail-recursive functions, are known to be less suitable for manipulation. In this paper, we propose a program transformation named “IO swapping” that swaps call-time and return-time computations. It moves computations in accumulative parameters to results and thereby enables interesting transformations. We demonstrate effectiveness of IO swapping by several applications: deforestation, higher order removal, program inversion, and manipulation of circular programs.

scholarly journals An incremental, exploratory and transformational environment for lazy functional programming

1993 ◽  
Vol 3 (1) ◽  
pp. 93-115 ◽  
Author(s):  
Colin Runciman ◽  
Ian Toyn ◽  
Mike Firth
Keyword(s):  
Functional Programming ◽  
Program Transformation ◽  
Functional Languages ◽  
Functional Language ◽  
Programming Environment ◽  
Programming Environments ◽  
Program Construction ◽  
Execution Tracing ◽  
Lazy Functional Programming

AbstractMost programming environments for functional languages offer a single tool used to evaluate programs – either a batch compiler or an interpreter with a read-eval-print loop. This paper presents a programming environment that supports not only evaluation, but also a range of other programming activities including transformation. The environment is designed to encourage working in an incremental and exploratory style, avoiding constraints on the order in which things must be done yet guarenteeing security. What has already been done towards the development of a program automatically persists, as does information about what has yet to be done. For instance, new laws can be introduced as conjectures and used in program transformation, but full details of proof obligations and dependencies are maintained.The paper outlines the functional language supported by the environment, and uses an extended example to illustrate program construction, execution, tracing, modification and transformation.

scholarly journals Making legacy Fortran code type safe through automated program transformation

2021 ◽  
Author(s):  
Wim Vanderbauwhede
Keyword(s):  
Side Effect ◽  
Program Transformation ◽  
The Novel ◽  
Formal Approach ◽  
Type Checking ◽  
Type Safety ◽  
Fortran Code ◽  
Fortran 90 ◽  
Code Type ◽  
Fortran 77

AbstractFortran is still widely used in scientific computing, and a very large corpus of legacy as well as new code is written in FORTRAN 77. In general this code is not type safe, so that incorrect programs can compile without errors. In this paper, we present a formal approach to ensure type safety of legacy Fortran code through automated program transformation. The objective of this work is to reduce programming errors by guaranteeing type safety. We present the first rigorous analysis of the type safety of FORTRAN 77 and the novel program transformation and type checking algorithms required to convert FORTRAN 77 subroutines and functions into pure, side-effect free subroutines and functions in Fortran 90. We have implemented these algorithms in a source-to-source compiler which type checks and automatically transforms the legacy code. We show that the resulting code is type safe and that the pure, side-effect free and referentially transparent subroutines can readily be offloaded to accelerators.

Sign in / Sign up

Export Citation Format

Share Document