- Haskell-Cafe - Haskell.org

ANN: hledger 0.6.1 released
by Simon Michael 22 Jun '09

22 Jun '09

I have released hledger 0.6.1 which fixes a build problem with ghc 6.8. You can ignore this release if you use a newer ghc or if one of the http://hledger.org/binaries works for you. Thanks to Andreas Reuleaux for the report. More reports welcome on irc, list or http://code.google.com/p/hledger/issues . Best, -Simon (sm)

1 0

Re: [Haskell-cafe] rewrite rules
by Daniel Schüssler 22 Jun '09

22 Jun '09

Hi Sjoerd, I don't know the cause of the problem, but if I add this rule, it works: {-# RULES "inline_map" forall g x. map g x = transform (. g) x -#} maybe, for whatever reason, the 'map' is inlined "too late" for the transform/transform rule to see it? Greetings, Daniel On Monday 22 June 2009 11:41:33 Sjoerd Visscher wrote: > Hi all, > > I have a rewrite rule as follows: > > {-# RULES > "transform/transform" forall (f::forall m. Monoid m => (a -> m) -> (b - > > > m)) > > (g::forall m. Monoid m => (b -> m) -> (c > -> m)) > (l::FMList c). transform f (transform g > l) = transform (g.f) l > #-} > > It fires on this code: > > print $ transform (. (*2)) (transform (. (+1)) (upto 10)) > > But it doesn't fire on this code: > > print $ map (*2) (map (+1) (upto 10))) > > with > > map g x = transform (. g) x > > and with or without {-# INLINE map #-}. > > What am I doing wrong? > > -- > Sjoerd Visscher > sjoerd(a)w3future.com > > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

ICFP09 Call for Participation
by Matthew Fluet (ICFP Publicity Chair) 22 Jun '09

22 Jun '09

===================================================================== Call for Participation The 14th ACM SIGPLAN International Conference on Functional Programming (ICFP 2009) http://www.cs.nott.ac.uk/~gmh/icfp09.html Edinburgh, Scotland, 31 August - 2 September 2009 ===================================================================== ICFP 2009 provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. The conference covers the entire spectrum of work, from practice to theory, including its peripheries. Preliminary program: * Accepted papers: + http://web.cecs.pdx.edu/~apt/icfp09_accepted_papers/accepted.html * Invited speakers: + Guy Steele -- Organizing Functional Code for Parallel Execution: or, foldl and foldr Considered Slightly Harmful + Benjamin Pierce -- Lambda, the Ultimate TA: Using a Proof Assistant to Teach Programming Language Foundations +Dan Piponi -- Commutative Monads, Diagrams and Knots Schedule including related workshops: * Aug 30: ACM SIGPLAN Workshop on ML * Aug 30: ACM SIGPLAN Workshop on Generic Programming * Aug 31-Sep 2: ICFP09 * Sep 3: ACM SIGPLAN Haskell Symposium * Sep 3: ACM SIGPLAN Developer Tracks on Functional Programming * Sep 4: Commercial Users of Functional Programming * Sep 4: ACM SIGPLAN Workshop on Mechanizing Metatheory * Sep 4: ACM SIGPLAN Workshop on Approaches and Applications of Inductive Programming * Sep 5: ACM SIGPLAN Erlang Workshop * Sep 5: ACM SIGPLAN Developer Tracks on Functional Programming * Sep 5: ACM SIGPLAN Haskell Implementors Workshop Registration information: * http://www.regmaster.com/conf/icfp2009.html * Early registration deadline: July 30, 2009 Local arrangements (including travel and accommodation): * http://www.haskell.org/haskellwiki/ICFP_2009_Local_Arrangements * Conference reservation/rate deadline: July 20, 2009 * ICFP09 coincides with the final week of the Edinburgh International Festival, one of the premier arts and cultural festivals in the world. The opportunity to attend the Festival is a plus! Due to the popularity of Edinburgh during the festival period, we strongly recommend booking accommodation early. Conference organizers: * General Chair: Graham Hutton (University of Nottingham) * Program Chair: Andrew Tolmach (Portland State University) * Local Arrangements Chairs: Philip Wadler (University of Edinburgh), Kevin Hammond (University of St Andrews), and Gregory Michaelson (Heriot-Watt University) * Workshop Co-Chairs: Christopher Stone (Harvey Mudd College), and Michael Sperber (DeinProgramm) * Programming Contest Chair: Andrew Gill (University of Kansas) * Publicity Chair: Matthew Fluet (Toyota Technological Institute at Chicago) ===================================================================== ===================================================================== And, don't forget about the ICFP Programming Contest this weekend!! * http://www.icfpcontest.org * Friday, June 26 to Monday, June 29 * Organizers: Computer Systems Design Laboratory (University of Kansas)

1 0

Documentation on hackage
by Uwe Schmidt 22 Jun '09

22 Jun '09

Dear Haskellers, who needs this kind of documentation? http://hackage.haskell.org/packages/archive/tfp/0.2/doc/html/Types-Data-Num… isn't this a kind of spam? Cheers, Uwe

8 7

Cross platform getProcessID
by John Van Enk 22 Jun '09

22 Jun '09

In the unix package, we have getProcessID. Is there a corresponding method for finding the process ID in Windows? /jve

2 2

Creating a new Haskell mailing list
by Ryan Trinkle 22 Jun '09

22 Jun '09

Hi all, I'm interested in starting a mailing list on haskell.org. Who should I talk to about such things? Thanks, Ryan

4 5

traversal transformations
by Sjoerd Visscher 22 Jun '09

22 Jun '09

Hi, While playing with Church Encodings of data structures, I realized there are generalisations in the same way Data.Foldable and Data.Traversable are generalisations of lists. The normal Church Encoding of lists is like this: > newtype List a = L { unL :: forall b. (a -> b -> b) -> b -> b } It represents a list by a right fold: > foldr f z l = unL l f z List can be constructed with cons and nil: > nil = L $ \f -> id > cons a l = L $ \f -> f a . unL l f Oleg has written about this: http://okmij.org/ftp/Haskell/zip-folds.lhs Now function of type (b -> b) are endomorphisms which have a Data.Monoid instance, so the type can be generalized: > newtype FM a = FM { unFM :: forall b. Monoid b => (a -> b) -> b } > fmnil = FM $ \f -> mempty > fmcons a l = FM $ \f -> f a `mappend` unFM l f Now lists are represented by (almost) their foldMap function: > instance Foldable FM where > foldMap = flip unFM But notice that there is now nothing list specific in the FM type, nothing prevents us to add other constructor functions. > fmsnoc l a = FM $ \f -> unFM l f `mappend` f a > fmlist = fmcons 2 $ fmcons 3 $ fmnil `fmsnoc` 4 `fmsnoc` 5 *Main> getProduct $ foldMap Product fmlist 120 Now that we have a container type represented by foldMap, there's nothing stopping us to do a container type represented by traverse from Data.Traversable: {-# LANGUAGE RankNTypes #-} import Data.Monoid import Data.Foldable import Data.Traversable import Control.Monad import Control.Applicative newtype Container a = C { travC :: forall f b . Applicative f => (a -> f b) -> f (Container b) } czero :: Container a cpure :: a -> Container a ccons :: a -> Container a -> Container a csnoc :: Container a -> a -> Container a cpair :: Container a -> Container a -> Container a cnode :: Container a -> a -> Container a -> Container a ctree :: a -> Container (Container a) -> Container a cflat :: Container (Container a) -> Container a czero = C $ \f -> pure czero cpure x = C $ \f -> cpure <$> f x ccons x l = C $ \f -> ccons <$> f x <*> travC l f csnoc l x = C $ \f -> csnoc <$> travC l f <*> f x cpair l r = C $ \f -> cpair <$> travC l f <*> travC r f cnode l x r = C $ \f -> cnode <$> travC l f <*> f x <*> travC r f ctree x l = C $ \f -> ctree <$> f x <*> travC l (traverse f) cflat l = C $ \f -> cflat <$> travC l (traverse f) instance Functor Container where fmap g c = C $ \f -> travC c (f . g) instance Foldable Container where foldMap = foldMapDefault instance Traversable Container where traverse = flip travC instance Monad Container where return = cpure m >>= f = cflat $ fmap f m instance Monoid (Container a) where mempty = czero mappend = cpair Note that there are all kinds of "constructors", and they can all be combined. Writing their definitions is similar to how you would write Traversable instances. So I'm not sure what we have here, as I just ran into it, I wasn't looking for a solution to a problem. It is also all quite abstract, and I'm not sure I understand what is going on everywhere. Is this useful? Has this been done before? Are there better implementations of foldMap and (>>=) for Container? Finally, a little example. A Show instance (for debugging purposes) which shows the nesting structure. newtype ShowContainer a = ShowContainer { doShowContainer :: String } instance Functor ShowContainer where fmap _ (ShowContainer x) = ShowContainer $ "(" ++ x ++ ")" instance Applicative ShowContainer where pure _ = ShowContainer "()" ShowContainer l <*> ShowContainer r = ShowContainer $ init l ++ "," ++ r ++ ")" instance Show a => Show (Container a) where show = doShowContainer . traverse (ShowContainer . show) greetings, -- Sjoerd Visscher sjoerd(a)w3future.com

2 7

packages on Hackage?
by Vasili I. Galchin 22 Jun '09

22 Jun '09

Hello, Haskell packages on Hackage can be hosted anywhere, yes? If a Haskell package is hosted on Hackage, how often is it backed up? Vasili

3 3

Slightly off-topic: Lambda calculus
by Andrew Coppin 22 Jun '09

22 Jun '09

OK, so I'm guessing there might be one or two (!) people around here who know something about the Lambda calculus. I've written a simple interpretter that takes any valid Lambda expression and performs as many beta reductions as possible. When the input is first received, all the variables are renamed to be unique. Question: Does this guarantee that the reduction sequence will never contain name collisions? I have a sinking feeling that it does not. However, I can find no counter-example as yet. If somebody here can provide either a proof or a counter-example, that would be helpful.

10 17

ANN: haskell-src-exts 1.0.0 rc1 (aka 0.5.2)
by Niklas Broberg 22 Jun '09

22 Jun '09

Fellow Haskelleers, I'm pleased to report that I feel I have now completed the first milestone in my GSoC project for haskell-src-exts: Full Code Support. This means I feel ready to take that scary leap that means to drop the safe 0.x version numbering (experimental) and finally make the first stable release, version 1.0.0. But before I take that leap I want the library to be thoroughly tested, so I can with confidence say that it truly *is* stable. Therefore, I hereby announce the release on hackage of haskell-src-exts-0.5.2, which I consider (almost) a release candidate for 1.0.0. * Via cabal: cabal install haskell-src-exts * On Hackage: http://hackage.haskell.org/package/haskell-src-exts-0.5.2 * Via darcs: darcs get http://code.haskell.org/haskell-src-exts I would be delighted if as many as possible would consider testing it on their code, even those of you who feel that you may not have any immediate use of the library, just to cover as much code base as possible in the hunt for potential bugs and misfeatures. Testing it is really easy, four simple steps: > cabal install haskell-src-exts [...] > ghci [...] Prelude> :m Language.Haskell.Exts Prelude Language.Haskell.Exts> parseFile "YourFileHere.(l)hs" If you get a parse error on a file that you feel should have been accepted, let me know! If the parser gives you an AST result for a file that you feel it shouldn't have accepted, let me know! Here's the bug tracker: http://trac.haskell.org/haskell-src-exts/report/1 The reason I say it is "almost" a release candidate is that while I consider the functionality to be in place, I will tidy up the exports, add a few more convenient functions to export, and add a lot of documentation, before I make the actual release. If you have a request for a particularly conventient function to add to the list of exports from the package, it's thus not too late to get it into 1.0.0. :-) What's cool in haskell-src-exts-0.5.2: ============================ * Support for all syntactic extensions supported by GHC, with two exceptions: UnicodeSyntax and NewQualifiedOperators. These will likely be added in the next feature release. Exclusive support for the newly registered XmlSyntax and RegularPatterns extensions. No support (yet) for Hugs-specific extensions (RestrictedTypeSynonyms, ExtensibleRecords, HereDocuments). No support for CPP. Also does not support the GHC-specific relaxation of layout in do-blocks, which is an unregistered extension (that should be registered!). * Support for parametrising the parsing on what extensions it should recognise. With no extensions given, it assumes Haskell98. Note that 'parseFile' will look for language pragmas in your source file to decide what extensions to use when parsing. If you want to be explicit, you can use 'parseFileWithExts', or 'parseFileWithMode' that lets you set a few other things as well. I intend to add some convenient names of extension groups, such as 'ghcExtensions' and 'glasgowExts', this is one area where I would particularly welcome suggestions. * Support for correct fixities of infix operators. By default it uses the fixities defined in the Prelude, as well as in the current document (including local let-bound fixities). Use 'parseFileWithMode' to set a different set of fixities. Language.Haskell.Exts.Fixity defines preludeFixities and baseFixities (all fixities defined in the base package), as well as combinators for defining your own sets. Much thanks to Neil Mitchell for the meat of this code. * No (known) bugs! :-) Special note for users of HaRP/HSP: I've uploaded a new version of hsx, hsx-0.5.0, that works with haskell-src-exts-0.5.2. There is one known bug in this version though, it cannot handle 'proc' entities from the Arrows extensions, I'm still considering how to fix that. In the mean time you can use it just fine, as long as your files don't contain any 'proc' blocks (which the old version couldn't handle anyway). Cheers and happy Haskelling, /Niklas

3 7