December 2006 - Haskell

Simple variable-state `monad'
by oleg＠pobox.com 18 Dec '06

18 Dec '06

The familiar State monad lets us represent computation with a state that can be queried and updated during the computation. The state must have the same type during the entire computation however. One sometimes wants to express a computation where not only the value but the type of the state can be updated as well -- while maintaining static typing. David Roundy has recently suggested a similar `restricted monad' > class WitnessMonad wm where > (>>=) :: wm w w' a -> (a -> wm w' w'' b) -> wm w w'' b > (>>) :: wm w w' a -> wm w' w'' b -> wm w w'' b > return :: a -> wm w w' a > fail :: String -> wm w w' a > > which obviously just adds a couple of phantom types indicating the monad > state prior to and after each operation. I actually rather like this > redefined monad, as it seems like it'd be useful in lots of places (e.g. a > restricted IO monad that disallows use of a file handle after it's > closed). To nitpick, such a `restricted monad' no longer can be called `monad' because the type of the bind operation does not satisfy the signature m a -> (a -> m b) -> m b. Proper naming is important so we can understand what kind of animal we're dealing with and so can chose the right way to domesticate it. The problem indeed shows up in many contexts, like ensuring that a file cannot be used after it is closed, or that the lock is properly released. The most common solution to these problems (expressing control-flow proiperties) involves using monad in a contra-variant position. One recent example http://pobox.com/~oleg/ftp/Haskell/yield.hs is ensuring a locking property (a lock can be unlocked only when it is held; one can acquire the same lock several times but must release that many times; no `yield' may be invoked while holding a lock). However, this style is a bit ugly. One wonders if a more direct expression of this `variable style monad' is possible. It seems it is, as the following code demonstrates. It runs with GHC 6.4 and Hugs. {-# OPTIONS -fglasgow-exts #-} -- Variable state monad module EM1 where import Control.Monad.State class Monadish m where gret :: a -> m p p a gbind :: m p q a -> (a -> m q r b) -> m p r b -- Inject regular monads to be monadish things too newtype MW m p q a = MW{ unMW:: m a } instance Monad m => Monadish (MW m) where gret = MW . return gbind (MW m) f = MW (m >>= unMW . f) -- As a warm-up, we write the regular State computation, with the same -- type of state throughout -- First, use the regular Monad.State test1 = runState c (0::Int) where c = do v <- get put (succ v) return v -- (0,1) -- Now, wrap in MW test2 = runState (unMW c) (0::Int) where c = gget `gbind` ( \v -> gput (succ v) `gbind` ( \_ -> gret v)) gget :: (MonadState s m) => MW m s s s gget = MW get gput :: (MonadState s m) => s -> MW m s s () gput = MW . put -- (0,1) -- Introduce the variable-type state newtype VST m si so v = VST{runVST:: si -> m (so,v)} instance Monad m => Monadish (VST m) where gret x = VST (\si -> return (si,x)) gbind (VST m) f = VST (\si -> m si >>= (\ (sm,x) -> runVST (f x) sm)) vsget :: Monad m => VST m si si si vsget = VST (\si -> return (si,si)) vsput :: Monad m => so -> VST m si so () vsput x = VST (\si -> return (x,())) -- Repeat test2 via VST: the type of the state is the same test3 = runVST c (0::Int) >>= print where c = vsget `gbind` ( \v -> vsput (succ v) `gbind` ( \_ -> gret v)) -- (1,0) -- Now, we vary the type of the state, from Int to a Char test4 = runVST c (0::Int) >>= print where c = vsget `gbind` ( \v -> vsput ((toEnum (65+v))::Char) `gbind` ( \_ -> vsget `gbind` ( \v' -> gret (v,v')))) -- ('A',(0,'A')) {- -- The following is an error: Couldn't match `Char' against `Int' Expected type: VST m Char r b Inferred type: VST m Int Int Bool test4' = runVST c (0::Int) >>= print where c = vsget `gbind` ( \v -> vsput ((toEnum (65+v))::Char) `gbind` ( \_ -> vsget `gbind` ( \v' -> gret (v==v')))) -} -- Try polymorphic recursion, over the state. -- crec1 invokes itself, and changes the type of the state from -- some si to Bool. crec1 :: (Enum si, Monad m) => VST m si si Int crec1 = vsget `gbind` (\s1 -> case fromEnum s1 of 0 -> gret 0 1 -> vsput (pred s1) `gbind` (\_ -> gret 1) _ -> vsput True `gbind` (\_ -> crec1 `gbind` (\v -> (vsput s1 `gbind` -- restore state type to si (\_ -> gret (v + 10)))))) test5 = runVST crec1 'a' >>= print -- ('a',11)

1 0

PhD Position, the University of Nottingham
by Henrik Nilsson 17 Dec '06

17 Dec '06

Postgraduate Research in Functional Hybrid Modelling School of Computer Science and IT University of Nottingham The University of Nottingham has an open position for a PhD student to work on EPSRC-funded project called Functional Hybrid Modelling, running for three years. This is a project at the intersection of, on the one hand, programming language semantics, design, and implementation, and, on the other, hybrid modelling and simulation. The ideal applicant would have a first- or upper-second class honours degree or equivalent in Computer Science (or possibly other area of direct relevance to the project), along with expertise in one or more of the following: * functional programming; * semantics, design, and implementation of (declarative) languages; * techniques for (hybrid) modelling and simulation, and related fields of mathematics (numerical methods, numerical analysis, calculus, linear algebra); * modelling and simulation of physical systems. The position is open to UK and EU applicants, but particularly strong applicants from outside the EU may also be considered, subject to the possibilities of securing additional funding. The successful applicant will work within the Foundations of Programming group at the School of Computer Science and IT: http://www.cs.nott.ac.uk/Research/fop/ The group currently comprise 7 academic staff, 5 research staff, and 14 research students. The research areas of the group include Algebra of Programming, Functional Programming (theory and practice), and Logic in Computer Science. The group is a founder member of the Midlands Graduate School in the Foundations of Computer Science, which provides postgraduate courses for PhD students in theoretical computer science. For further information on the studentship and the project, please contact Henrik Nilsson: nhn(a)cs.nott.ac.uk http://www.cs.nott.ac.uk/~nhn -- Henrik Nilsson School of Computer Science and Information Technology The University of Nottingham nhn(a)cs.nott.ac.uk This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

An haskell-fr community ?!
by Olivier Thauvin 17 Dec '06

17 Dec '06

Hi, I just setup a web site, a mailing list and an irc channel on freenode as it seems few people were interested (like me) by an haskell-fr community. Honnestly, I am not sure this website will have a big success, but trying is often better than nothing. I am myself an haskell beginner, but I hope I'll use haskell soon so easilly than I use perl, and so providing many contributions and modules. Any comments and contributions are of course welcome ! OOpppps, the url: http://haskell-fr.zarb.org/ Regards.

2 1

Ranged Sets 0.0.4
by Paul Johnson 17 Dec '06

17 Dec '06

Ranged Sets now have a Monoid instance, and singletons (i.e. a range holding a single value). Thanks to Jean-Philippe Bernardy for the patch. Paul.

1 0

[ANN] Edison 1.2.1
by Robert Dockins 16 Dec '06

16 Dec '06

Fellow Haskellers, I am pleased to announce the 1.2.1 release of Edison. Edison is a library of efficient, purely-functional data structures in Haskell. Notable changes from version 1.2.0.1: * A new sequence implementation based on finger trees (similar to Data.Sequence in the base libs). * Documenation fixes dealing with the licence (the docs previously and incorrectly claimed Edison was under the BSD licence, when it is in fact the MIT license). * Added a few methods to EnumSet for wrapping and unwrapping the underlying Word The project home page is: http://www.eecs.tufts.edu/~rdocki01/ edison.html From here you can find source tarballs, online Haddock docs and the darcs repository. Rob Dockins Speak softly and drive a Sherman tank. Laugh hard; it's a long way to the bank. -- TMBG

1 0

Re: [Haskell] ANNOUNCE: Basic serialization library using only existing SYB infrastructure
by Stefan O'Rear 16 Dec '06

16 Dec '06

> > darcs get http://members.cox.net/stefanor/genericserialize > > got the following error: > > darcs failed: Failed to download URL http://members.cox.net/stefanor/genericserialize/_darcs/patches/ Apparently the FTP upload failed yesterday; I reran it. From now on I'll test the uploads :) (The re-upload was tested successfully) I apologize for the inconvienience.

1 0

Haskell alternatives: functional programming in rich IDEs
by Bulat Ziganshin 15 Dec '06

15 Dec '06

Hello haskell, it was several times mentioned that Haskell doesn't provide rich environments for productive work, including lack of IDEs, bundled "real-world" libs and so on. i want to mention alternative environments that is better in these areas 1) F#, is Ocaml dialect integrated in .NET environment 2) Clean, very Haskell-like language with a commercial IDE, GUI libs and so on 3) Business Objects, integration of Haskell-like language into Java environment, http://labs.businessobjects.com/cal -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

3 2

PAPP 2007 CfP deadline extended
by Clemens Grelck 15 Dec '06

15 Dec '06

========================================= **** Deadline extension: December 20, 2006 **** Fourth International Workshop on Practical Aspects of High-level Parallel Programming (PAPP 2007) part of The International Conference on Computational Science May 27-30, 2007, University of Beijing, China http://graal.ens-lyon.fr/~abenoit/conf/papp2007.html ========================================= Aims and scope Computational Science applications are more and more complex to develop and require more and more computing power. Parallel and grid computing are solutions to the increasing need for computing power. High level languages offer a high degree of abstraction which ease the development of complex systems. Moreover, being based on formal semantics, it is possible to certify the correctness of critical parts of the applications. Algorithmic skeletons, parallel extensions of functional languages such as Haskell and ML, parallel logic and constraint programming, parallel execution of declarative programs such as SQL queries, etc. have produced methods and tools that improve the price/performance ratio of parallel software, and broaden the range of target applications. The PAPP workshop focuses on practical aspects of high-level parallel programming: design, implementation and optimization of high-level programming languages and tools (performance predictors working on high-level parallel/grid source code, visualisations of abstract behaviour, automatic hotspot detectors, high-level GRID resource managers, compilers, automatic generators, etc.), applications in all fields of computational science, benchmarks and experiments. Research on high-level grid programming is particularly relevant. The PAPP workshop is aimed both at researchers involved in the development of high level approaches for parallel and grid computing and computational science researchers who are potential users of these languages and tools. Topics We welcome submission of original, unpublished papers in English on topics including: * high-level models (CGM, BSP, MPM, LogP, etc.) and tools for parallel and grid computing * high-level parallel language design, implementation and optimisation * functional, logic, constraint programming for parallel, distributed and grid computing systems * algorithmic skeletons, patterns and high-level parallel libraries * generative (e.g. template-based) programming with algorithmic skeletons, patterns and high-level parallel libraries * applications in all fields of high-performance computing (using high-level tools) * benchmarks and experiments using such languages and tools Paper submission and publication Prospective authors are invited to submit full papers in English presenting original research. Submitted papers must be unpublished and not submitted for publication elsewhere. Papers will go through a rigorous reviewing process. Each paper will be reviewed by at least three referees. The accepted papers will be published in the Springer-Verlag Lecture Notes in Computer Science (LNCS) series, as part of the ICCS proceedings. Submission must be done through the ICCS website: http://www.iccs-meeting.org/iccs2007/papers/upload.php. We invite you to submit a full paper of 8 pages formatted according to the rules of LNCS, describing new and original results, no later than December 20, 2006. Submission implies the willingness of at least one of the authors to register and present the paper. An early email to papp2007 at free.fr with your intention to submit a paper would be greatly appreciated (especially if you have doubts about the relevance of your paper). Accepted papers should be presented at the workshop. Authors will be invited to submit extended and revised versions of their papers. Accepted manuscripts will be published in a special issue of Scalable Computing: Practice and Experience. Important Dates * December 20, 2006 - Full paper due * February 3, 2007 - Notification * February 19, 2007 - Camera-ready paper due * July 2007 - Journal version due * September 2007 - Referee reports * October 2007 - Revision of papers, final notification * November 2007 - Final paper due Programme committee * Marco Aldinucci (Univ. of Pisa, Italy) * Anne Benoit (ENS Lyon, France) * Armelle Bonenfant (Univ. of St Andrews, UK) * Frédéric Gava (Univ. Paris XII Val de Marne, France) * Alexandros Gerbessiotis (NJIT, USA) * Clemens Grelck (Univ. of Luebeck, Germany) * Zhenjiang Hu (Univ. of Tokyo, Japan) * Rita Loogen (Univ. of Marburg, Germany) * Frédéric Loulergue (Univ. Orléans, France) * Susanna Pelagatti (Univ. of Pisa, Italy) * Casiano Rodriguez Leon (Univ. La Laguna, Spain) Organizers * Dr. Anne BENOIT Laboratoire d'Informatique du Parallelisme Ecole Normale Supérieure de Lyon 46 Allée d'Italie 69364 Lyon Cedex 07 - France * Pr. Frederic LOULERGUE Laboratoire d'Informatique Fondamentale d'Orléans Université d'Orléans Batiment IIIA - Rue Léonard de Vinci - BP6759 45067 Orléans Cedex 2 - France

1 0

ANNOUNCE: Basic serialization library using only existing SYB infrastructure
by Stefan O'Rear 15 Dec '06

15 Dec '06

Announcing GenericSerialize, a library for serialization using the existing generic-programming framework. It is often advocated that support for serialization should be added to the compiler (e.g. in the form of a deriving(Binary)). With this I intend to show that the existing infrastructure is sufficient, and has some advantages over a dedicated serialization interface. The main advantage that generic serialization posseses is that it is possible to simultaneously have several serialization modes. While interfaces such as AltBinary allow writing to any type of stream, the data format is fixed. By contrast, GenericSerialize supports multiple serialization modes; while the only currently existing module is for a subset of R5RS s-expressions, that module is less than 100 lines of code and is almost pure grammar. See the included README for (minimal...) usage examples. darcs get http://members.cox.net/stefanor/genericserialize wget http://members.cox.net/stefanor/genericserialize-0.0.tar.gz

1 0

ANNOUNCE: Phooey -- a Functional UI library for Haskell
by Conal Elliott 14 Dec '06

14 Dec '06

Announcing Phooey <http://conal.net/phooey>, a functional UI library for Haskell. GUIs are usually programmed in an "unnatural" style, in that implementation dependencies are inverted, relative to logical dependencies. This reversal results directly from the imperative orientation of most GUI libraries. While outputs depend on inputs from a user and semantic point of view, the imperative approach imposes an implementation dependence of inputs on outputs. Phooey ("*Ph*unctional *oo*s*e*r *y*nterfaces") retains the functional style, in which outputs are expressed in terms of inputs. In addition, Phooey supports dynamic input bounds, flexible layout, and mutually-referential widgets. As an example of Phooey's style, below is a simple shopping list GUI. The * total* displayed at the bottom of the window always shows the sum of the values of the *apples* and *bananas* input sliders. When a user changes the inputs, the output updates accordingly. Phooey is structured as an arrow, and this example uses arrow notation. The code: ui1 :: UI () () ui1 = title "Shopping List" $ proc () -> do a <- title "apples" (islider 3) -< (0,10) b <- title "bananas" (islider 7) -< (0,10) title "total" showDisplay -< a+b I am working on a paper about Phooey. For now, please see the Haddock documentation <http://darcs.haskell.org/packages/phooey/doc> (which includes more examples), and try the code via darcs get http://darcs.haskell.org/packages/phooey --partial Directions for building are in the README<http://darcs.haskell.org/packages/phooey/README>file. Distribution tarballs are here <http://darcs.haskell.org/packages/phooey/dist>. Comments and collaboration are very welcome! Cheers, - Conal P.S. I'm very grateful for Don Stewart's recent pointers on how to create & release Haskell projects.

5 8