[Haskell-cafe] Fourth Ghent Functional Programming Group Meeting on Thursday, Oct 7th: Program, Final Details and BelHac Commercial

Jeroen Janssen jejansse at gmail.com
Thu Sep 30 14:03:55 EDT 2010

(apologies if you receive multiple copies)

Dear All,

We are pleased to announce that the fourth Ghent Functional Programming Group (GhentFPG) meeting will take place on Thursday, October 7th, at 19h in the Technicum building of Ghent University (Sint-Pietersnieuwstraat 41, 9000 Gent). As before, you should enter through the electronic sliding doors on the left. The doors will be locked, but there will be a sign with a number that you can call to get in.

The final program for our fourth meeting is as follows:

1. Stijn Timbermont - Mapping Interpreters onto Runtime Support

When constructing an interpreter, it is hard to achieve a concise and abstract definition of the language semantics and at the same time have sufficient control over how the underlying runtime support is implemented. We illustrate with a number of examples that gaining more control over runtime support implementation forces us to adopt a more machine-like interpreter structure. This is problematic for reuse and evolution of interpreters. We present a solution to this problem that automates this restructuring of interpreters. The solution is based on three cornerstones: the theory of defunctionalized interpreters, effect-driven transformations and generic programming. It allows us to start from a concise and abstract definition of the language features and automatically transform it into a more machine-like form that allows for a customized runtime support implementation to be integrated.

2. Tom Schrijvers - Dictionaries: Eager or Lazy Type Class Witnesses?

Type classes are Haskell’s acclaimed solution to ad-hoc overloading.
This talk gives an introductory overview of type classes and their
runtime witnesses, dictionaries.
It asks the questions whether dictionaries should abide by Haskell’s
default lazy evaluation strategy.

   Conceptually, a type class is a type-level predicate: a type is an
   instance of a type class iff it provides an implementation for
   overloaded functions. For instance, `Eq a’ declares that type `a’
   implements a function `(==) :: a → a → Bool’ for checking equality.

   Type classes are used as constraints on type variables, in so-called
   constrained polymorphic functions. E.g. `sort :: Ord a => [a] → [a]’
   sorts a list with any type of elements `a’ that are an instance of the
   Ord type class, i.e. provide implementations for comparison.

Witnesses for type class constraints are necessary to select the
appropriate implementation
for the overloaded functions at runtime. For instance, if `sort’ is
called with Int elements,
the Int comparison must be used, versus say Float comparison for Float elements.

Two forms of witnesses have been considered in the literature, runtime
type representations
and so-called dictionaries, of which the latter are the most most
commonly implementation,
e.g., in GHC . Haskell implementations treat dictionaries just like
all other data, as lazy values
that may potentially consists of non-terminating computations. This
way part of the type checker’s
work, who has made sure that the dictionaries do exist, is simply forgotten.
Is this really necessary?

3. Dominique Devriese - Grammar Combinators - A new model for shallow parser DSL's

Parser combinator libraries are a well-known alternative to parser
generators in the functional programming community. However, their
power is currently fundamentally limited by their representation of
recursion in context-free grammars. We present the grammar-combinators
Haskell library which removes these limitations, and brings some other
advantages (semantic value family polymorphism, natural concepts). In
this talk, I will briefly explain the motivation for the library, and
then present our approach and some of its most important aspects in a
live demonstration and finish with a discussion.

Last, note that GhentFPG is organizing the first Belgian Haskell Hackathon, called BelHac, on 5-7 November 2010. The fifth GhentFPG meeting will take place at BelHac and will focus on talks concerning the use of functional programming in industry.
More info will be provided soon.

As usual, if you want get all the latest info on GhentFPG, you can subscribe to our google group (http://groups.google.com/group/ghent-fpg) or follow us on twitter (@ghentfpg).

Hope to see you at both of these events!

The GhentFPG Organizing committee.

More information about the Haskell-Cafe mailing list