We present a new model, based on monads, for performing input/output in a non-strict, purely functional language. It is composable, extensible, efficient, requires no extensions to the type system, and extends smoothly to incorporate mixed-language working and in-place array updates.

/pdf/imperative-functional-programming-ymikz542ki.pdf

Imperative functional programming

Category theorists invented monads in the 1960's to concisely express certain aspects of universal algebra. Functional programmers invented list comprehensions in the 1970's to concisely express certain programs involving lists. This paper shows how list comprehensions may be generalised to an arbitrary monad, and how the resulting programming feature can concisely express in a pure functional language some programs that manipulate state, handle exceptions, parse text, or invoke continuations. A new solution to the old problem of destructive array update is also presented. No knowledge of category theory is assumed.

Comprehending monads

Symposium on Haptic Interfaces for Virtual Environment and Teleoperator Systems 参加報告

Lava is a tool to assist circuit designers in specifying, designing, verifying and implementing hardware. It is a collection of Haskell modules. The system design exploits functional programming language features, such as monads and type classes, to provide multiple interpretations of circuit descriptions. These interpretations implement standard circuit analyses such as simulation, formal verification and the generation of code for the production of real circuits.Lava also uses polymorphism and higher order functions to provide more abstract and general descriptions than are possible in traditional hardware description languages. Two Fast Fourier Transform circuit examples illustrate this.

http://www.cse.chalmers.se/edu/year/2012/course/_courses_2011/TDA956/Papers/Lava98.pdf

Lava: hardware design in Haskell

Software engineering demands generality and abstraction, performance demands specialization and concretization. Generative programming can provide both, but the effort required to develop high-quality program generators likely offsets their benefits, even if a multi-stage programming language is used.We present lightweight modular staging, a library-based multi-stage programming approach that breaks with the tradition of syntactic quasi-quotation and instead uses only types to distinguish between binding times. Through extensive use of component technology, lightweight modular staging makes an optimizing compiler framework available at the library level, allowing programmers to tightly integrate domain-specific abstractions and optimizations into the generation process.We argue that lightweight modular staging enables a form of language virtualization, i.e. allows to go from a pure-library embedded language to one that is practically equivalent to a stand-alone implementation with only modest effort.

Lightweight modular staging: a pragmatic approach to runtime code generation and compiled DSLs

A wide range of domain-specific languages (DSLs) has been implemented successfully by embedding them in general purpose languages. This paper reviews embedding, and summarizes how two alternative techniques – staged interpreters and templates – can be used to overcome the limitations of embedding. Both techniques involve a form of generative programming. The paper reviews and compares three programming languages that have special support for generative programming. Two of these languages (MetaOCaml and Template Haskell) are research languages, while the third (C++) is already in wide industrial use. The paper identifies several dimensions that can serve as a basis for comparing generative languages.

https://link.springer.com/content/pdf/10.1007%2F978-3-540-25935-0_4.pdf

DSL Implementation in MetaOCaml, Template Haskell, and C++

Hydra is a set of methods and software tools for carrying out digital circuit design using Haskell. It has been used successfully for three years in the third-year course on Computer Architecture at the University of Glasgow, with plans to extend its use to the advanced fourth-year course. Some of its innovative features are: Signal type classes; support for CMOS and NMOS design; a large family of higher order combining forms; a set of tools for simulation; a language for expressing control algorithms; and automated tools for deriving control circuits from control algorithms. The system contains a rich library of circuits, ranging from low level implementations of logic gates using pass transistors to complete processor designs. The chief benefit of using functional circuit specification to teach computer architecture is that a complete computer system design can be presented, at all levels of abstraction, with no details omitted, giving students a genuine understanding of how computers work.

Teaching functional circuit specification in Hydra

It is easy to write a circuit specification in a pure functional language so that execution of the specification simulates the circuit. It’s harder to make an executable specification generate the circuit’s netlist without using impure language features. The difficulty is that a circuit specification evaluates to a graph isomorphic to the circuit, so the specification of a circuit with feedback will evaluate to a circular (or infinite) graph. That prevents a naive graph traversal algorithm written in a pure functional language from terminating. This paper solves the problem by requiring the circuit specification to name components explicitly. With suitable higher order functions, the naming can be achieved without placing an undue burden on the circuit designer. This approach clarifies the distinction between transformations that preserve both the behaviour and structure of a circuit and transformations that preserve the behaviour while possibly changing the structure. It also demonstrates one way to manipulate circular graphs in a pure functional language.

Generating Netlists from Executable Circuit Specifications in a Pure Functional Language

Hydra is a computer hardware description language that integrates several kinds of software tool (simulation, netlist generation and timing analysis) within a single circuit specification. The design language is inherently concurrent, and it offers black box abstraction and general design patterns that simplify the design of circuits with regular structure. Hydra specifications are concise, allowing the complete design of a computer system as a digital circuit within a few pages. This paper discusses the motivations behind Hydra, and illustrates the system with a significant portion of the design of a basic RISC processor.

/pdf/overview-of-hydra-a-concurrent-language-for-synchronous-1hsn0zoa3l.pdf

Overview of hydra: a concurrent language for synchronous digital circuit design

For some time functional language researchers have experimented with non-deterministic constructs for these otherwise deterministic languages One strong motivation to do so is the desire to express necessarily non-deterministic programs, such as operating systems and interactive systems that service requests from several terminals in the order in which they are made Another motivation is that some parallel algorithms are internally non-deterministic even though their result is not Since functional languages are claimed to be well suited to parallel programming we certainly wish to be able to express such algorithms Non-determinism can also be related to program refinement: a non-deterministic function may be considered to be a specification which is refined to a deterministic implementation We will not address this third aspect here

John T. O'Donnell

Papers

DSL Implementation in MetaOCaml, Template Haskell, and C++

Teaching functional circuit specification in Hydra

Generating Netlists from Executable Circuit Specifications in a Pure Functional Language

Overview of hydra: a concurrent language for synchronous digital circuit design

Expressing and Reasoning About Non-Deterministic Functional Programs