scholarly journals Higher order interpretation for higher order complexity

10.29007/1tkw ◽  
2018 ◽  
Author(s):  
Emmanuel Hainry ◽  
Romain Péchoux
Keyword(s):  
Complexity Analysis ◽  
Higher Order ◽  
Functional Language ◽  
Higher Order Functions

We design an interpretation-based theory of higher-order functions that is well-suited for the complexity analysis of a standard higher- order functional language a` la ml. We manage to express the interpretation of a given program in terms of a least fixpoint and we show that when restricted to functions bounded by higher-order polynomials, they characterize exactly classes of tractable functions known as Basic Feasible Functions at any order.

Hoare type theory, polymorphism and separation

2008 ◽  
Vol 18 (5-6) ◽  
pp. 865-911 ◽  
Author(s):  
ALEKSANDAR NANEVSKI ◽  
GREG MORRISETT ◽  
LARS BIRKEDAL
Keyword(s):  
Type Theory ◽  
Higher Order ◽  
Separation Logic ◽  
Functional Language ◽  
Individual Program ◽  
Small Footprint ◽  
Program Components ◽  
Pointer Aliasing ◽  
Higher Order Functions ◽  
Order State

AbstractWe consider the problem of reconciling a dependently typed functional language with imperative features such as mutable higher-order state, pointer aliasing, and nontermination. We propose Hoare type theory (HTT), which incorporates Hoare-style specifications into types, making it possible to statically track and enforce correct use of side effects.The main feature of HTT is the Hoare type {P}x:A{Q} specifying computations with preconditionPand postconditionQthat return a result of typeA. Hoare types can be nested, combined with other types, and abstracted, leading to a smooth integration with higher-order functions and type polymorphism.We further show that in the presence of type polymorphism, it becomes possible to interpret the Hoare types in the “small footprint” manner, as advocated by separation logic, whereby specifications tightly describe the state required by the computation.We establish that HTT is sound and compositional, in the sense that separate verifications of individual program components suffice to ensure the correctness of the composite program.

A polymorphic library for constructive solid geometry

1995 ◽  
Vol 5 (3) ◽  
pp. 415-442
Author(s):  
J. R. Davy ◽  
P. M. Dew
Keyword(s):  
Higher Order ◽  
Divide And Conquer ◽  
Functional Language ◽  
Constructive Solid Geometry ◽  
Solid Modelling ◽  
General Applicability ◽  
Solid Geometry ◽  
Recurrent Patterns ◽  
Higher Order Functions

AbstractSolid modelling using constructive solid geometry (CSG) includes many examples of stylised divide-and-conquer algorithms. We identify the sources of these recurrent patterns and describe a Geometric Evaluation Library (GEL) which captures them as higher-order functions. This library then becomes the basis of developing CSG applications quickly and concisely. GEL is currently implemented as a set of separately compiled modules in the pure functional language Hope+. We evaluate our work in terms of performance and general applicability. We also assess the benefits of the functional paradigm in this domain and the merits of programming with a set of higher-order functions.

PROLOG'S CONTROL CONSTRUCTS IN A FUNCTIONAL SETTING — AXIOMS AND IMPLEMENTATION

2001 ◽  
Vol 12 (02) ◽  
pp. 125-170 ◽  
Author(s):  
RALF HINZE
Keyword(s):  
Canonical Form ◽  
Higher Order ◽  
Exception Handling ◽  
Functional Language ◽  
Iso Standard ◽  
Error Handling ◽  
Definition Of ◽  
Functional Setting ◽  
Higher Order Functions

The purpose of this article is twofold. First, we show that Prolog's control constructs can be smoothly integrated into a functional language like Haskell. The resulting 'language', termed embedded Prolog, incorporates many of the features prescribed by the Prolog ISO standard: control constructs including the cut, all solution collecting functions, and error handling facilities. Embedded Prolog lacks some concepts such as logical variables but it inherits all of Haskell's strengths, eg static polymorphic typing, higher order functions etc. Technically, the integration is achieved using monads and monad transformers. One of the main innovations is the definition of a backtracking monad transformer, which allows us to combine backtracking with exception handling and interaction. Second, we work towards an axiomatization of the operations, through which the computational features are accessed. Equations are used to lay down the meaning of the various operations and their interrelations enabling the programmer to reason about programs in a simple calculational style. The axiomatization is applied to show that each finite computation has a simple canonical form.

scholarly journals Voigt Transform and Umbral Image

2020 ◽  
Vol 25 (3) ◽  
pp. 49
Author(s):  
Silvia Licciardi ◽  
Rosa Maria Pidatella ◽  
Marcello Artioli ◽  
Giuseppe Dattoli
Keyword(s):  
Spectroscopic Studies ◽  
Higher Order ◽  
Point Of View ◽  
The Other ◽  
Pivotal Role ◽  
Umbral Calculus ◽  
Laguerre Functions ◽  
Hermite And Laguerre Functions ◽  
Higher Order Functions ◽  
Voigt Function

In this paper, we show that the use of methods of an operational nature, such as umbral calculus, allows achieving a double target: on one side, the study of the Voigt function, which plays a pivotal role in spectroscopic studies and in other applications, according to a new point of view, and on the other, the introduction of a Voigt transform and its possible use. Furthermore, by the same method, we point out that the Hermite and Laguerre functions, extension of the corresponding polynomials to negative and/or real indices, can be expressed through a definition in a straightforward and unified fashion. It is illustrated how the techniques that we are going to suggest provide an easy derivation of the relevant properties along with generalizations to higher order functions.

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.

Sign in / Sign up

Export Citation Format

Share Document