Conjunctive Type Systems and Abstract Interpretation of Higher-order Functional Programs

1995 ◽  
Vol 5 (4) ◽  
pp. 397-421 ◽  
Author(s):  
THOMAS P. JENSEN
Keyword(s):  
Abstract Interpretation ◽  
Type Systems ◽  
Higher Order

A system of constructor classes: overloading and implicit higher-order polymorphism

1995 ◽  
Vol 5 (1) ◽  
pp. 1-35 ◽  
Author(s):  
Mark P. Jones
Keyword(s):  
Type System ◽  
Type Systems ◽  
Natural Generalization ◽  
Higher Order ◽  
Functional Language ◽  
Effective Algorithm ◽  
Prototype Implementation ◽  
Type Classes

AbstractThis paper describes a flexible type system that combines overloading and higher-order polymorphism in an implicitly typed language using a system of constructor classes—a natural generalization of type classes in Haskell. We present a range of examples to demonstrate the usefulness of such a system. In particular, we show how constructor classes can be used to support the use of monads in a functional language. The underlying type system permits higher-order polymorphism but retains many of the attractive features that have made Hindley/Milner type systems so popular. In particular, there is an effective algorithm that can be used to calculate principal types without the need for explicit type or kind annotations. A prototype implementation has been developed providing, amongst other things, the first concrete implementation of monad comprehensions known to us at the time of writing.

scholarly journals Exploiting reachability and cardinality in higher-order flow analysis

2008 ◽  
Vol 18 (5-6) ◽  
pp. 821-864 ◽  
Author(s):  
MATTHEW MIGHT ◽  
OLIN SHIVERS
Keyword(s):  
Abstract Interpretation ◽  
Garbage Collection ◽  
Flow Analysis ◽  
Higher Order ◽  
Order Flow ◽  
Environment Analysis ◽  
Running Time

AbstractWe present two complementary improvements for abstract-interpretation-based flow analysis of higher-order languages: (1) abstract garbage collection and (2) abstract counting. Abstract garbage collection is an analog to its concrete counterpart: the analysis determines when an abstract resource has become unreachable, and then, re-allocates it as fresh. This prevents flow sets from joining during abstract interpretation, which has two immediate effects: (1) the precision of the interpretation increases and (2) its running time often falls. In abstract counting, the analysis tracks how many times an abstract resource has been allocated. A count of one implies that the abstract resource momentarily represents only one concrete resource. This knowledge, in turn, drives environment analysis, expanding the kind (rather than just the degree) of optimization available to the compiler.

scholarly journals Bounded Fixed Point Iteration

1991 ◽  
Vol 20 (359) ◽  
Author(s):  
Hanne Riis Nielson ◽  
Flemming Nielson
Keyword(s):  
Fixed Point ◽  
Abstract Interpretation ◽  
Higher Order ◽  
Monotone Functions ◽  
Additive Functions ◽  
Fixed Point Iteration ◽  
Exponential Bound ◽  
Strictness Analysis ◽  
Long Chains

In the context of abstract interpretation for languages without higher-order features we study the number of times a functional need to be unfolded in order to give the least fixed point. For the cases of total or monotone functions we obtain an exponential bound and in the case of strict and additive (or distributive) functions we obtain a quadratic bound. These bounds are shown to be tight in that sufficiently long chains of functions can be shown to exist. Specializing the case of strict and additive functions to functionals of a form that would correspond to iterative programs we show that a linear bound is tight. This is related to several analyses studied in the literature (including strictness analysis).

scholarly journals Higher order symbolic execution for contract verification and refutation

2016 ◽  
Vol 27 ◽  
Author(s):  
PHÚC C. NGUYÊN ◽  
SAM TOBIN-HOCHSTADT ◽  
DAVID VAN HORN
Keyword(s):  
Symbolic Execution ◽  
Type Systems ◽  
Higher Order ◽  
Control Flow ◽  
Test Case ◽  
Modular Verification ◽  
Automated Test Case Generation ◽  
Behavioral Contracts ◽  
Virtuous Cycle ◽  
And Control

AbstractWe present a new approach to automated reasoning about higher-order programs by endowing symbolic execution with a notion of higher-order, symbolic values. To validate our approach, we use it to develop and evaluate a system for verifying and refuting behavioral software contracts of components in a functional language, which we call soft contract verification. In doing so, we discover a mutually beneficial relation between behavioral contracts and higher-order symbolic execution. Contracts aid symbolic execution by providing a rich language of specifications serving as a basis of symbolic higher-order values; the theory of blame enables modular verification and leads to the theorem that verified components can't be blamed; and the run-time monitoring of contracts enables soft verification whereby verified and unverified components can safely interact. Conversely, symbolic execution aids contracts by providing compile-time verification and automated test case generation from counter-examples to verification. This relation between symbolic exuection and contracts engenders a virtuous cycle encouraging the gradual use of contracts.Our approach is able to analyze first-class contracts, recursive data structures, unknown functions, and control-flow-sensitive refinements of values, which are all idiomatic in dynamic languages. It makes effective use of off-the-shelf solvers to decide problems without heavy encodings. Counterexample search is sound and relatively complete with respect to a first-order solver for base type values and counter-examples are reported as concrete values, including functions. Therefore, it can form the basis of automated verification and bug-finding tools for higher-order programs. The approach is competitive with a range of existing tools—including type systems, flow analyzers, and model checkers—on their own benchmarks. We have built a prototype to analyze programs written in Racket and report on its effectiveness in verifying and refuting contracts.

A syntactic method for finding least fixed points of higher-order functions over finite domains

1997 ◽  
Vol 7 (4) ◽  
pp. 357-394
Author(s):  
TYNG-RUEY CHUANG ◽  
BENJAMIN GOLDBERG
Keyword(s):  
Fixed Point ◽  
Fixed Points ◽  
Normal Forms ◽  
Abstract Interpretation ◽  
Higher Order ◽  
Semantic Domain ◽  
Recent Developments ◽  
Strictness Analysis ◽  
Finite Domains ◽  
Higher Order Functions

This paper describes a method for finding the least fixed points of higher-order functions over finite domains using symbolic manipulation. Fixed point finding is an essential component in the calculation of abstract semantics of functional programs, providing the foundation for program analyses based on abstract interpretation. Previous methods for fixed point finding have primarily used semantic approaches, which often must traverse large portions of the semantic domain even for simple programs. This paper provides the theoretical framework for a syntax-based analysis that is potentially very fast. The proposed syntactic method is based on an augmented simply typed lambda calculus where the symbolic representation of each function produced in the fixed point iteration is transformed to a syntactic normal form. Normal forms resulting from successive iterations are then compared syntactically to determine their ordering in the semantic domain, and to decide whether a fixed point has been reached. We show the method to be sound, complete and compositional. Examples are presented to show how this method can be used to perform strictness analysis for higher-order functions over non-flat domains. Our method is compositional in the sense that the strictness property of an expression can be easily calculated from those of its sub-expressions. This is contrary to most strictness analysers, where the strictness property of an expression has to be computed anew whenever one of its subexpressions changes. We also compare our approach with recent developments in strictness analysis.

Fixed points and frontiers: a new perspective

1991 ◽  
Vol 1 (1) ◽  
pp. 91-120 ◽  
Author(s):  
Sebastian Hunt ◽  
Chris Hankin
Keyword(s):  
Fixed Points ◽  
Abstract Interpretation ◽  
Higher Order ◽  
Upper And Lower Bounds ◽  
Elegant Method ◽  
Computation Of Fixed Points ◽  
New Perspective ◽  
New Formulation ◽  
Intractable Problem ◽  
Higher Order Functions

AbstractAbstract interpretation is the collective name for a family of semantics-based techniques for compile-time analysis of programs. One of the most costly operations in automating such analyses is the computation of fixed points. The frontiers algorithm is an elegant method, invented by Chris Clack and Simon Peyton Jones, which addresses this issue.In this article we present a new approach to the frontiers algorithm based on the insight that frontiers represent upper and lower subsets of a function's argument domain. This insight leads to a new formulation of the frontiers algorithm for higher-order functions, which is considerably more concise than previous versions.We go on to argue that for many functions, especially in the higher-order case, finding fixed points is an intractable problem unless the sizes of the abstract domains are reduced. We show how the semantic machinery of abstract interpretation allows us to place upper and lower bounds on the values of fixed points in large lattices by working within smaller ones.

scholarly journals Systematic abstraction of abstract machines

2012 ◽  
Vol 22 (4-5) ◽  
pp. 705-746 ◽  
Author(s):  
DAVID VAN HORN ◽  
MATTHEW MIGHT
Keyword(s):  
Programming Languages ◽  
Static Analysis ◽  
Abstract Interpretation ◽  
Garbage Collection ◽  
Higher Order ◽  
Return Flow ◽  
Initial Development ◽  
Abstract Machines ◽  
Temporal Ordering

AbstractWe describe a derivational approach to abstract interpretation that yields novel and transparently sound static analyses when applied to well-established abstract machines for higher-order and imperative programming languages. To demonstrate the technique and support our claim, we transform the CEK machine of Felleisen and Friedman (Proc. of the 14th ACM SIGACT-SIGPLAN Symp. Prin. Program. Langs, 1987, pp. 314–325), a lazy variant of Krivine's machine (Higher-Order Symb. Comput. Vol 20, 2007, pp. 199–207), and the stack-inspecting CM machine of Clements and Felleisen (ACM Trans. Program. Lang. Syst. Vol 26, 2004, pp. 1029–1052) into abstract interpretations of themselves. The resulting analyses bound temporal ordering of program events; predict return-flow and stack-inspection behavior; and approximate the flow and evaluation of by-need parameters. For all of these machines, we find that a series of well-known concrete machine refactorings, plus a technique of store-allocated continuations, leads to machines that abstract into static analyses simply by bounding their stores. These machines are parameterized by allocation functions that tune performance and precision and substantially expand the space of analyses that this framework can represent. We demonstrate that the technique scales up uniformly to allow static analysis of realistic language features, including tail calls, conditionals, mutation, exceptions, first-class continuations, and even garbage collection. In order to close the gap between formalism and implementation, we provide translations of the mathematics as running Haskell code for the initial development of our method.

Sign in / Sign up

Export Citation Format

Share Document