Structure and interpretation of computer programs

Functional and logic programming are the most important declarative programming paradigms, and interest in combining them has grown over the last decade. Early research concentrated on the definition and improvement of execution principles for such integrated languages, while more recently efficient implementations of these execution principles have been developed so that these languages became relevant for practical applications. In this paper, we survey the development of the operational semantics as well as the improvement of the implementation of functional logic languages.

/pdf/the-integration-of-functions-into-logic-programming-from-3tssg4mb8y.pdf

The Integration of Functions into Logic Programming: From Theory to Practice

Publisher Summary This chapter discusses the mathematical theory of computation. Computation essentially explores how machines can be made to carry out intellectual processes. Any intellectual process that can be carried out mechanically can be performed by a general purpose digital computer. There are three established directions of mathematical research that are relevant to the science of computation—namely, numerical analysis, theory of computability, and theory of finite automata. The chapter explores what practical results can be expected from a suitable mathematical theory. Further, the chapter presents several descriptive formalisms with a few examples of their use and theories that enable to prove the equivalence of computations expressed in these formalisms. A few mathematical results about the properties of the formalisms are also presented.

A Basis for a Mathematical Theory of Computation

Narrowing is the operational principle of languages that integrate functional and logic programming. We propose a notion of a needed narrowing step that, for inductively sequential rewrite systems, extends the Huet and Le´vy notion of a needed reduction step. We define a strategy, based on this notion, that computes only needed narrowing steps. Our strategy is sound and complete for a large class of rewrite systems, is optimal w.r.t. the cost measure that counts the number of distinct steps of a derivation, computes only independent unifiers, and is efficiently implemented by pattern matching.

/pdf/a-needed-narrowing-strategy-2hjvj7gxzt.pdf

A needed narrowing strategy

ion: A[x/τ ] ` e :: τ ′ A ` \x->e :: τ → τ ′ if τ is a type expression Existential: A[x/τ ] ` e :: τ ′ A ` let x free in e :: τ ′ if τ is a type expression Figure 1: Typing rules for Curry programs where T is a type constructor of arity n, as defined by a datatype declaration (cf. Section 2.1),7 and τ1, . . . , τn are type expressions (note that list, tuple and function types have the special syntax [·], (·,· · ·,·), and ·->· as described above). For instance, [(Int,a)]->a is a type expression containing the type variable a. A type scheme is a type expression with a universal quantification for some type variables, i.e., it has the form ∀α1, . . . , αn.τ (n ≥ 0; in case of n = 0, the type scheme is equivalent to a type expression). A function type declaration f::τ is considered as an assignment of the type scheme ∀α1, . . . , αn.τ to f , where α1, . . . , αn are all type variables occurring in τ . The type τ is called a generic instance of the type scheme ∀α1, . . . , αn.τ ′ if there is a substitution σ = {α1 7→ τ1, . . . , αn 7→ τn} on the types with σ(τ ′) = τ . The types of all defined functions are collected in a type environment A which is a mapping from identifiers to type schemes. It contains at least the type schemes of the defined functions and an assignment of types for some local variables. An expression e is well-typed and has type τ w.r.t. a type environment A if A ` e :: τ is derivable according to the inference rules shown in Figure 1. A defining equation f t1 . . . tn = e [where x free] is well-typed w.r.t. a type environment A if A(f) = ∀α1, . . . , αm.τ [and A(x) is a type expression] and A ` \t1-> · · · \tn->e :: τ is derivable according to the above inference rules. A conditional equation l | c = r is considered (for the purpose of typing) as syntactic sugar for l = cond c r where cond is a new function with type scheme A(cond) = ∀α.Success→ α→ α. A program is well-typed if all its rules are well-typed with a unique assignment of type schemes to defined functions.8 Note that the following recursive definition is a well-typed Curry program according to the definition above (and the type definitions given in the prelude, cf. Appendix B): f :: [a] -> [a] f x = if length x == 0 then fst (g x x) else x g :: [a] -> [b] -> ([a],[b]) g x y = (f x, f y) We assume here that all type constructors introduced by type synonyms (cf. Section 2.2) are replaced by their definitions. Here we assume that all local declarations are eliminated by the transformations described in Appendix D.7.

Curry: an integrated functional logic language (version 0

ion: A[x/τ ] ` e :: τ ′ A ` \x->e :: τ → τ ′ if τ is a type expression Existential: A[x/τ ] ` e :: Success A ` let x free in e :: Success if τ is a type expression Conditional: A ` e1 :: Bool A ` e2 :: τ A ` e3 :: τ A ` if e1 then e2 else e3 :: τ Figure 1: Typing rules for Curry programs equivalent to a type expression). A function type declaration f::τ is considered as an assignment of the type scheme ∀α1, . . . , αn.τ to f , where α1, . . . , αn are all type variables occurring in τ . The type τ is called a generic instance of the type scheme ∀α1, . . . , αn.τ ′ if there is a substitution σ = {α1 7→ τ1, . . . , αn 7→ τn} on the types with σ(τ ′) = τ . The types of all defined functions are collected in a type environment A which is a mapping from identifiers to type schemes. It contains at least the type schemes of the defined functions and an assignment of types for some local variables. An expression e is well-typed and has type τ w.r.t. a type environment A if A ` e :: τ is derivable according to the inference rules shown in Figure 1. A defining equation f t1 . . . tn = e [where x free] is well-typed w.r.t. a type environment A if A(f) = ∀α1, . . . , αm.τ [and A(x) is a type expression] and A ` \t1-> · · · \tn->e :: τ is derivable according to the above inference rules. A conditional equation l | c = r is considered (for the purpose of typing) as syntactic sugar for l = cond c r where cond is a new function with type scheme A(cond) = ∀α.Success→ α→ α. A program is well-typed if all its rules are well-typed with a unique assignment of type schemes to defined functions.10 Note that the following recursive definition is a well-typed Curry program according to the definition above (and the type definitions given in the prelude, cf. Appendix B): f :: [a] -> [a] f x = if length x == 0 then fst (g x x) else x g :: [a] -> [b] -> ([a],[b]) g x y = (f x, f y) h :: ([Int],[Bool]) h = g [3,4] [True,False] However, if the type declaration for g is omitted, the usual type inference algorithms are not able Here we assume that all local declarations are eliminated by the transformations described in Appendix D.8.

/pdf/curry-an-integrated-functional-logic-language-2hyme0g929.pdf

Curry: An Integrated Functional Logic Language

TOY is the concrete implementation of CRWL, a wide theoretical framework for declarative programming whose basis is a constructor based rewriting logic with lazy non-deterministic functions as the core notion. Other aspects of CRWL supported by TOY are: polymorphic types; HO features; equality and disequality constraints over terms and linear constraints over real numbers; goal solving by needed narrowing combined with constraint solving. The implementation is based on a compilation of TOY programs into Prolog.

http://gpd.sip.ucm.es/fraguas/papers/RTA99.pdf

TOY: A Multiparadigm Declarative System

We propose an approach to declarative programming which integrates the functional and relational paradigms by taking possibly non-deterministic lazy functions as the fundamental notion. Classical equational logic does not supply a suitable semantics in a natural way. Therefore, we suggest to view programs as theories in a constructor-based conditional rewriting logic. We present proof calculi and a model theory for this logic, and we prove the existence of free term models which provide an adequate intended semantics for programs. We develop a sound and strongly complete lazy narrowing calculus, which is able to support sharing without the technical overhead of graph rewriting and to identify safe cases for eager variable elimination. Moreover, we give some illustrative programming examples, and we discuss the implementability of our approach.

An approach to declarative programming based on a rewriting logic

Many recent proposals for the integration of functional and logic programming use conditional term rewriting systems (CTRS) as programs and narrowing as goal solving mechanism. This paper specifies a computation strategy for lazy conditional narrowing, based on the idea of transforming patterns into decision trees to control the computation. The specification is presented as a translation of CTRS into Prolog, which makes it executable and portable. Moreover, in comparison to related approaches, our method works for a wider class of CTRS.

A Demand Driven Computation Strategy for Lazy Narrowing

We propose an approach to declarative programming which integrates the functional and relational paradigms by taking possibly non-deterministic lazy functions as the fundamental notion. Programs in our paradigm are theories in a constructor-based conditional rewriting logic. We present proof calculi and a model theory for this logic, and we prove the existence of free term models which provide an adequate intended semantics for programs. Moreover, we develop a sound and strongly complete lazy narrowing calculus, which is able to support sharing without the technical overhead of graph rewriting and to identify safe cases for eager variable elimination.

/pdf/a-rewriting-logic-for-declarative-programming-58uwa15mx7.pdf

Francisco Javier López-Fraguas

Papers

Curry: An Integrated Functional Logic Language

TOY: A Multiparadigm Declarative System

An approach to declarative programming based on a rewriting logic

A Demand Driven Computation Strategy for Lazy Narrowing

A Rewriting Logic for Declarative Programming