Efficient type inference for higher-order binding-time analysis

1991 ◽  
pp. 448-472 ◽  
Author(s):  
Fritz Henglein
Keyword(s):  
Higher Order ◽  
Type Inference ◽  
Time Analysis ◽  
Binding Time ◽  
Efficient Type ◽  
Binding Time Analysis

scholarly journals Binding Time Analysis: Abstract Interpretation vs. Type Inference

1992 ◽  
Vol 21 (393) ◽  
Author(s):  
Jens Palsberg ◽  
Michael I. Schwartzbach
Keyword(s):  
Abstract Interpretation ◽  
Lambda Calculus ◽  
Type Inference ◽  
Time Analysis ◽  
Binding Time ◽  
Better Than ◽  
Binding Time Analysis

Binding time analysis is important in partial evaluators. Its task is to determine which parts of a program can be specialized if some of the expected input is known. Two approaches to do this are abstract interpretation and type inference. We compare two specific such analyses to see which one determines most program parts to be eliminable. The first is the abstract interpretation approach of Bondorf, and the second is the type inference approach o£ Gomard. Both apply to the untyped lambda calculus. We prove that Bondorf's analysis is better than Gomard's.

scholarly journals Efficient analyses for realistic off-line partial evaluation

1993 ◽  
Vol 3 (3) ◽  
pp. 315-346 ◽  
Author(s):  
Anders Bondorf ◽  
Jesper Jørgensen
Keyword(s):  
Linear Time ◽  
Partial Evaluation ◽  
Flow Analysis ◽  
Higher Order ◽  
Time Analysis ◽  
Specific Order ◽  
Binding Time ◽  
And Function ◽  
Constraint Sets ◽  
Binding Time Analysis

AbstractBased on Henglein's efficient binding-time analysis for the lambda calculus (with constants and ‘fix’) (Henglein, 1991), we develop three efficient analyses for use in the preprocessing phase of Similix, a self-applicable partial evaluator for a higher-order subset of Scheme. The analyses developed in this paper are almost-linear in the size of the analysed program. (1) A flow analysis determines possible value flow between lambda-abstractions and function applications and between constructor applications and selector/predicate applications. The flow analysis is not particularly biased towards partial evaluation; the analysis corresponds to the closure analysis of Bondorf (1991b). (2) A (monovariant) binding-time analysis distinguishes static from dynamic values; the analysis treats both higher-order functions and partially static data structures. (3) A new is-used analysis, not present in Bondorf (1991b), finds a non-minimal binding-time annotation which is ‘safe’ in a certain way: a first-order value may only become static if its result is ‘needed’ during specialization; this ‘poor man's generalization’ (Holst, 1988) increases termination of specialization. The three analyses are performed sequentially in the above mentioned order since each depends on results from the previous analyses. The input to all three analyses are constraint sets generated from the program being analysed. The constraints are solved efficiently by a normalizing union/find-based algorithm in almost-linear time. Whenever possible, the constraint sets are partitioned into subsets which are solved in a specific order; this simplifies constraint normalization. The framework elegantly allows expressing both forwards and backwards components of analyses. In particular, the new is-used analysis is of backwards nature. The three constraint normalization algorithms are proved correct (soundness, completeness, termination, existence of a best solution). The analyses have been implemented and integrated in the Similix system. The new analyses are indeed much more efficient than those of Bondorf (1991b); the almost-linear complexity of the new analyses is confirmed by the implementation.

scholarly journals Polyvariant Analysis of the Untyped Lambda Calculus

1992 ◽  
Vol 21 (386) ◽  
Author(s):  
Jens Palsberg ◽  
Michael I. Schwartzbach
Keyword(s):  
Fixed Point ◽  
Program Transformation ◽  
Lambda Calculus ◽  
Safety Analysis ◽  
Type Inference ◽  
Simple Type ◽  
Time Analysis ◽  
Fixed Point Computation ◽  
Binding Time ◽  
Binding Time Analysis

<p>We present a polyvariant closure, safety, and binding time analysis for the untyped lambda calculus. The innovation is to analyze each abstraction afresh at all syntactic application points. This is achieved by a semantics-preserving program transformation followed by a novel monovariant analysis, expressed using type constraints. The constraints are solved in cubic time by a single fixed-point computation.</p><p>Safety analysis is aimed at determining if a term will cause an error during evaluation. We have recently proved that the monovariant safety analysis accepts strictly more terms than simple type inference. This paper demonstrates that the polyvariant transformation makes even more terms acceptable, even some without higher-order polymorphic types. Furthermore, polyvariant binding time analysis can improve the partial evaluators that base a polyvariant specialization on only monovariant binding time analysis.</p>

scholarly journals Enhanced type inference for binding-time analysis

2020 ◽  
Vol 12 (2) ◽  
pp. 232-250
Author(s):  
Mátyás Szokoli ◽  
Attila Kiss
Keyword(s):  
Type Inference ◽  
Time Analysis ◽  
Analysis Algorithm ◽  
Speed Difference ◽  
Binding Time ◽  
Dynamic Typing ◽  
Binding Time Analysis

Abstract In this paper we will be taking a look at type inference and its uses for binding-time analysis, dynamic typing and better error messages. We will propose a new binding-time analysis algorithm ℬ, which is a modification of an already existing algorithm by Gomard [4], and discuss the speed difference.

Sign in / Sign up

Export Citation Format

Share Document