Lazy Type Inference and Program Analysis

Abstract Approaches to static analysis based on nonstandard type systems have received considerable interest recently. Most work has concentrated on the relationship between such analyses and abstract interpretation. In this paper, we focus on the problem of producing efficient algorithms from such type-based analyses. The key idea is the introduction of laziness into type inference. We present the basic notions in the context of a higher-order strictness analysis of list-processing functions. We also present a general framework for program analysis based on these ideas. We conclude with some experimental results.

[1]  Nick Benton Strictness Logic and Polymorphic Invariance , 1992, LFCS.

[2]  Daniel Le Métayer,et al.  Proving the Correctness of Compiler Optimizations Based on Strictness Analysis , 1993, PLILP.

[3]  Olivier Danvy,et al.  CPS-transformation after strictness analysis , 1992, LOPL.

[4]  Benjamin Goldberg,et al.  A syntactic approach to fixed point computation on finite domains , 1992, LFP '92.

[5]  Nick Benton,et al.  Strictness Properties of Lazy Algebraic Datatypes , 1993, WSA.

[6]  Chris Hankin,et al.  A Type-based Framework for Program Analysis , 1994, SAS.

[7]  Chris Hankin,et al.  Deriving algorithms from type inference systems: application to strictness analysis , 1994, POPL '94.

[8]  Geoffrey L. Burn,et al.  A Logical Framework for Program Analysis , 1992, Functional Programming.

[9]  Pieter H. Hartel,et al.  Benchmarking implementations of lazy functional languages , 1993, FPCA '93.

[10]  Alan Mycroft,et al.  Abstract interpretation and optimising transformations for applicative programs , 1982 .

[11]  Paul Hudak,et al.  Higher-order strictness analysis in untyped lambda calculus , 1986, POPL '86.

[12]  David Sands,et al.  Binding time analysis: a new PERspective , 1991, PEPM '91.

[13]  Tsung-Min Kuo,et al.  Strictness analysis: a new perspective based on type inference , 1989, FPCA.

[14]  Prateek Mishra,et al.  Reasoning about Simple and Exhaustive Demand in Highter-Order Lazy Languages , 1991, FPCA.

[15]  Geoffrey L. Burn,et al.  Evaluation transformers - a model for the parallel evaluation of functional languages (extended abstract) , 1987, FPCA.

[16]  Laurent Mauborgne Abstract Interpretation Using TDGs , 1994, SAS.

[17]  Neil D. Jones,et al.  Data flow analysis of applicative programs using minimal function graphs , 1986, POPL '86.

[18]  Patrick Cousot,et al.  Static Determination of Dynamic Properties of Recursive Procedures , 1977, Formal Description of Programming Concepts.

[19]  Patrick Cousot,et al.  Comparing the Galois Connection and Widening/Narrowing Approaches to Abstract Interpretation , 1992, PLILP.

[20]  Dale Miller,et al.  From operational semantics to abstract machines , 1992, Mathematical Structures in Computer Science.

[21]  Mads Rosendahl Higher-Order Chaotic Iteration Sequences , 1993, PLILP.

[22]  Eric Nöcker,et al.  Strictness analysis using abstract reduction , 1993, FPCA '93.

[23]  Steffen van Bakel,et al.  Complete Restrictions of the Intersection Type Discipline , 1992, Theor. Comput. Sci..

[24]  Chris Hankin,et al.  Approximate Fixed Points in Abstract Interpretation , 1992, Sci. Comput. Program..

[25]  Geoffrey L. Burn,et al.  Assessing the evaluation transformer model of reduction on the spineless G-machine , 1993, FPCA '93.

[26]  John C. Mitchell,et al.  Type inference with simple subtypes , 1991, Journal of Functional Programming.

[27]  John Launchbury,et al.  Strictness and binding-time analyses: two for the price of one , 1991, PLDI '91.

[28]  Philip Wadler,et al.  Projections for strictness analysis , 1987, FPCA.

[29]  Sebastian Hunt,et al.  Abstract interpretation of functional languages: from theory to practice , 1991 .

[30]  Chris Hankin,et al.  Lazy Type Inference for the Strictness Analysis of Lists , 1994, ESOP.

[31]  M. J. Plasmeijer,et al.  Term graph rewriting: theory and practice , 1993 .

[32]  Marvin V. Zelkowitz,et al.  Programming Languages: Design and Implementation , 1975 .

[33]  Erich J. Neuhold,et al.  Formal description of programming concepts , 1991 .

[34]  Chris Hankin,et al.  Abstract Interpretation of Declarative Languages , 1987 .

[35]  Robin Milner,et al.  A Theory of Type Polymorphism in Programming , 1978, J. Comput. Syst. Sci..

[36]  Alex Ferguson,et al.  Fast Abstract Interpretation Using Sequential Algorithms , 1993, WSA.

[37]  Thomas P. Jensen,et al.  Strictness Analysis in Logical Form , 1991, FPCA.

[38]  SEBASTIAN HUNT,et al.  Fixed points and frontiers: a new perspective , 1991, Journal of Functional Programming.