http://www.comp.nus.edu.sg/aboutsoc/getting_to_soc_at_com1.htm http://www.comp.nus.edu.sg/corpcomm/location/maps.htm#com1 http://www.comp.nus.edu.sg/corpcomm/location/COM1_L2.htmThe meeting starts at 9:30am and should end around 2pmish (with a lunch-break,on your own, in between) Let Tom or Martin know if you are interested in coming. Either to attend the meeting or even give a talk.
We report on our Constraint Logic Programing framework for Haskell. The core concept of the framework is the search tree, which is explored by primitive search strategies. A primitive search strategy is defined by a queue datatype and can be extended by a search transformer. Moreover, multiple search transformers can be composed to obtain quite complex behavior. Note that our framework is generic in the underlying constraint solver, and in particular works for both backtracking and copying-based solvers.
Composable memory transactions are a new communication abstraction for Concurrent Haskell, which provides the programmer with a composable communication concept. Unfortunately, composable memory transactions are implemented as external functions for ghc and not available for other implementation of Concurrent Haskell. We present an implementation of memory transactions within Concurrent Haskell. The library can be executed within older ghc versions as well as with the popular Hugs system. Benchmarks show, that our library performes well. Furthermore, our (high-level) implementation can be extended and maintained more easily than the low-level implementation provided by ghc.
We report some preliminary results on integrating Constraint Handling Rules (CHR) into Haskell to support concurrent programming. CHR is rule-based language to describe concurrent transformations (rewritings) among multi-sets of constraints (atomic formulae). We give programming examples to explore the power of our extension and relate it to languages based on the join calculus. We have implemented a prototype in STM Haskell. Experimental results show that we can achieve significant speed-ups on multi-core architectures (more cores = programs runs faster).
We present an extension of Haskell, baptized XHaskell, which combines parametric polymorphism, algebraic data types and type classes found in Haskell with regular expression types, subtyping and regular expression pattern matching found in XDuce. We give programming examples and report on the current implementation status.
Program errors are hard to detect and are costly both to programmers who spend significant efforts in debugging, and to systems that are guarded by runtime checks. Static verification techniques have been applied to imperative and object-oriented languages, like Java and C#, but few have been applied to a higher-order lazy functional language, like Haskell. In this talk, I shall describe a sound and automatic static verification tool for Haskell, that is based on contracts and symbolic execution. Our approach gives precise blame assignments at compile-time in the presence of higher-order functions and laziness.
Comonads are dual to monads, but there are far more monads than their less glamorous twin. We use Haskell to search for more comonads, using the comonadic associative law as a starting point. Counterintuitively, the results suggest that comonads are more populous than monads.
Change in venue: COM1/240