chalmers, A graduate course by John Hughes Combinator libraries, nowadays often called Domain Specific Embedded Languages, offer an easy way to provide a customised programming language for a particular application domain. Such a language can greatly simplify applications. The idea of a DSEL is not specific to Haskell, but Haskell is an excellent "host language" to embed a customised language in, and indeed, this approach to programming has a long history in the functional language community. DSELs can be a valuable tool for researchers, because they support "exploratory language design". A researcher can identify appropriate abstractions in the problem domain, and rapidly build a DESL that embodies them to experiment with. This course will explain the combinator library idea, give many examples and applications, and discuss design principles to help you invent your own. We will also discuss research projects in several areas, where a DSEL is a key enabling technology.
An ingenious set of combinators for expressing pattern matching in a type-safe way. No ADTs required. Opens up the possibility of programming languages where we can declare new binding forms just as we declare new functions. abstract: Macros still have not made their way into typed higher-order programming languages such as Haskell and Standard ML. Therefore, to extend the expressiveness of Haskell or Standard ML gradually, one must express new linguistic features in terms of functions that fit within the static type systems of these languages. This is particularly challenging when introducing features that span across multiple types and that bind variables. We address this challenge by developing, in a step-by-step manner, mechanisms for encoding patterns and pattern matching in Haskell in a type-safe way.
Instructions for building under Windows This section gives detailed instructions for how to build GHC from source on your Windows machine. Similar instructions for installing and running GHC may be found in the user guide. Make sure you read the preceding section on platforms before reading section. You don't need Cygwin or MSYS to use GHC, but you do need one or the other to build GHC
Formerly Dr Haskell HLint can only be compiled by GHC 6.10.1 or above (it makes use of view patterns), but does not require any copy of GHC to run. HLint should be able to give hints for any Haskell code, including most GHC extensions
[TIMe - eMBEdded - Reactive] Timber is a general programming language specifically aimed at the construction of complex event-driven systems. It allows programs to be conveniently structured in terms of objects and reactions, and the real-time behavior of reactions can furthermore be precisely controlled via platform-independent timing constraints. This property makes Timber particularly suited to both the specification and the implementation of real-time embedded systems. Timber is deeply rooted in the functional programming tradition, although it also draws heavily on object-oriented concepts, and has the notion of concurrent execution built into its core.
There are two schools of thought when it comes to documenting programs and libraries: some embed fragments of code within the documentation (so called “literate programming”) and others embed fragments of documentation in their code (i.e. comments). The “comments” approach makes it easy to generate API documentation and the like (a feature built-in to Haskell’s Hackage system) but help me write blog posts and other documents containing code, which is where literate programming shines. Happily, Haskell supports both of these approaches and has a few rather useful tools available to make both easier. In this post, I’ll describe how to take literate Haskell with Markdown formatted text and produce syntax highlighted documents in HTML and PDF.
Timber program reacts to events sent to it from its execution environment. This process is potentially infinite, and the order of external events is not known in advance.To capture this intuition, Timber defines its primary run-time structure to be a set of interconnected reactive objects, that each encapsulate a piece of the global program state. A reactive object is a passive entity defined by a set of methods. Between invocations, a Timber object just maintains its state, ready to react . Timber objects evolve in parallel, although the methods belonging to a particular object are always run under mutually exclusion. Concurrency as well as state protection is thus implicit. Methods are either asynchronous or synchronous, as denoted by the keywords action and request, respectively. The most radical property of Timber is that it is free from any indefinitely blocking constructs; because of this, a Timber object is always fully responsive when not actively executing code.
Sarasvati is an open source workflow/business process management engine for Java and Haskell. It is currently in beta, and is already suitable for use in many projects.
This paper is an exploration in a functional programming framework of isomorphisms between elementary data types (natural numbers, sets, multisets, finite functions, permutations binary decision diagrams, graphs, hypergraphs, parenthesis languages, dyadic rationals, DNA sequences etc.) and their extension to hereditary finite universes through hylomorphisms derived from ranking/unranking and pairing/unpairing operations. An embedded higher order combinator language provides any-to-any encodings automatically. Besides applications to experimental mathematics, a few examples of "free algorithms" obtained by transferring operations between data types are shown. Other applications range from stream iterators on combinatorial objects to self-delimiting codes, succinct data representations and generation of random instancs. The paper covers 47 data types and, through the use of the embedded combinator language, provides 2162 distinct bijective transformations between them.
Tools such as NCover and the Haskell Program Coverage tool, it can ensure our honesty when it comes to tests, and we get a glaring reminder when we don't. These tools, when combined with our traditional xUnit and property-based tests with saturation test generation can be a satisfying experience. We've now covered the creation and combination of traditional xUnit tests with property-based tests and how to leverage code coverage as a tool for refining. There is still more to be covered in this series which includes refactoring.
In the previous post, we talked about some of the basics of functional programming unit testing. That post mostly focused around HUnit, which is a traditional xUnit testing framework. This time, let's focus on type-based property testing, which is to create specs which assert logical properties about a function, and then to generate data to test in an attempt to falsify these assertions, through the use of a tool called QuickCheck. Much like the traditional xUnit frameworks, this tool helps us flush out the specifications of our software through the use of tests. Unlike the xUnit frameworks, however, this framework allows us to create generators to help flush out our behaviors and capture our edge cases as we look for ways to falsify our tests. These generators could use either random data or well structured data that you can craft. Let's dive a little deeper into what that means.
Let's focus on the tooling around testing with functional languages. What kind of options do we have? In the Haskell world just as the F# world, there are several tools at our disposal to do this. * HUnit A traditional xUnit testing framework for unit testing. Analogous to such frameworks as xUnit.net, NUnit and MbUnit in the .NET world. * QuickCheck A program in which the developer provides a specification of the program, in the form of properties which functions should satisfy, and then tests that the properties hold in a large number of randomly generated cases that QuickCheck provides. There are many variants of this tool for most functional languages including F# (FsCheck), Erlang, Scala, Java, Python, Standard ML and others. Today we're going to focus on HUnit as part of developing an API in Haskell.
In the functional programming world, we have two main ways of testing our code, either through the traditional xUnit tests or the more powerful QuickCheck property-based tests. Each of these are powerful in their own right, but made more powerful when combined into a single unit. When combined we have the power of integrating them into our CI process through some of the build/package tools in our tool belt.
Twitter has become quite the hotbed of chatter about functional programming over the past few months, as a substantial number of pretty well known FP people have either been present all along or have signed up recently and started following each other. Here is a list of people I know about who tweet about FP on a semi-regular basis, along with what I think are their main interest
Efficiently translating Haskell to JVM Bytecode using GHC's intermediate language, STG. LambdaVM is the proof that complete and efficient translation is possible. LambdaVM is a set of patches to GHC's which extend it to fully support generating useable JVM bytecode. It modifies the three primary components of GHC: * The compiler itself: The compiler has been modified to transform STG, one of GHC's many intermediate languages, to JVM bytecode. * The runtime system (RTS): GHC's RTS implemented as a mix of C and C-- has been reimplemented in Java. * The base libraries: GHC's base libraries have been modified to run on top of Java's standard libraries rather than ANSI C/POSIX libraries. October, 2008 Update LambdaVM is coming back! I've fixed all the GHC 6.8.x build problems and the instructions below should once again work. LambdaVM itself is still based on a circa November, 2007 GHC HEAD but moving all my changes to the current HEAD is next
LambdaVM is a JVM backend for GHC. It is available at http://darcs.brianweb.net/ghc. October, 2008 Update See http://www.cs.rit.edu/~bja8464/lambdavm/ Documentation * Building Guide * FFI * Exceptions * Concurrency Misc Notes * Implementation * Todo * NestedVM Integration