December 2009 - Haskell-Cafe

Lambda's
by Henk-Jan van Tuyl 17 Feb '10

17 Feb '10

I love lambda's: http://hawtness.com/2009/12/30/wtf-girl-photo-more-reasons-why-half-life-is… -- Regards, Henk-Jan van Tuyl -- http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html --

11 11

parallel and distributed haskell?
by Scott A. Waterman 12 Feb '10

12 Feb '10

It looks like there was a recent hackathon focusing on implementing distributed haskell. http://hackage.haskell.org/trac/ghc/wiki/HackPar I feel there is quite a bit of latent interest in the subject here, but relatively little active development (compared to erlang, clojure, etc.) Can anyone involved give a quick overview (or pointers to one)? It would be good to hear what directions people are taking, and why, and where it's going. Personally, I'd love to know the current thinking on a variety of subjects: * erlang-like port/actor implementations v. more implicit constructs * serialization * node failure/error handling * "grid" compatibility v. various ad-hoc cluster approaches. Anyone actively looking at this kind of question who would want to talk about it? Thanks, --ts

7 8

ANN: Happstack 0.4.1
by Jeremy Shaw 11 Feb '10

11 Feb '10

Happstack 0.4.1 STABLE is now available. We recommend that all users of Happstack update to 0.4.1 immediately. Migration from Happstack 0.3 should be trivial. There was one race condition in happstack-state which could cause a state event to fail under heavy congestion. Happstack is the Haskell Application Server Stack. It is a scalable framework for developing web applications. It is similar in purpose to Django, RoR, Turbogears, Grails, Seaside, etc. Using less buzzwords, it is a collection of libraries which can be used to develop a self-contained server application which does not require SQL or Apache (though it can integrate with both). It includes: * an HTTP server * a rich DSL for deconstructing HTTP Requests and generating Responses * HTML/XML/etc templating via HStringTemplate, HSP, or Text.XHtml * a persistent data store based on user defined Haskell data types with ACID properties and state migration * and more!! Happstack's modular nature means it is easy to integrate unrelated 3rd party modules such as Pandoc, or to add support for an alternative templating system. Additionally, it does not exclude you from using SQL, or supporting other protocols besides HTTP. HOMEPAGE: http://www.happstack.com/ SUPPORTED PLATFORMS: Happstack supports GHC 6.8, 6.10, and 6.12, under GNU/Linux, FreeBSD, OS X, and Windows. GHC 6.12 currently requires a minor patch to HJScript. Details here: http://groups.google.com/group/haskell-server-pages/browse_thread/thread/56… INSTALL: 1. ensure that ~/.cabal/bin is in your $PATH 2. cabal update 3. cabal install happstack * see SUPPORTED PLATFORMS for information about GHC 6.12 NOTABLE CHANGES: For a complete list of changes see: http://www.patch-tag.com/r/mae/happstack/snapshots/all/history Removed: * happstack-contrib has been completely removed. If you were using something in it, please complain on the mailing list. * removed Happstack.Server.S3 -- newer, better maintained S3 libraries are on hackage now * removed unsupported spread-based multimaster support fileServe: * now with sendfile() support! On supported platforms sendfile allows files to be served from the disk to the network in a zero-copy fashion. This means faster transfers, less memory and CPU usage, and no file handle leaks. (hopefully). sendfile uses native sendfile() support on Linux, Windows, OS X, and FreeBSD. Other platforms will use a sendfile emulation mode. We recommend that you use sendFile instead of sendFileStrict or sendFileLazy, unless you have specific needs and know some reason why you must use sendFileStrict or sendFileLazy. * FileServe internals majorly refactored. FileServe now provides a modular way of building your own fileServe-like functions. Also includes functions for serving a single file instead of the contents of a directory. * added more complete list of mime-types * automatically redirect from foo to foo/ if foo is a directory * filter . and .. from request path, but allow filenames and directories which start with . happstack-server: * ServerMonad instance for ErrorT * Added ServerMonad, FilterMonad, and WebMonad for XMLGenT * Added secure flag to cookies. Defaults to False. * fix supportsIPv6 to work with newer versions of network library * simpleHTTPWithSocket + bindPort for H.S.SimpleHTTP (you can use this to start the server as root, bind to the socket, and then drop privileges.) * Fixed Accept-Encoding parser to accepts encodings with a - in them. Added additional tests to acceptEncodingParserTest * fix so basicAuth sets correct response code and headers. * SimpleHTTP: added trailingSlash. Guard which checks that Request URI ends with a / * decode body of PUT requests not just POST * added ifModifiedSince guard * added host and withHost guards to SimpleHTTP (similar to dir and path, but for the requested hostname) other: * happstack-state: Correct an embarrassing race condition bug. * happstack-data: Exported getSafeGet and getSafePut * happstack: add state transition code to guestbook (add email to form, handler, and state), and tar of example _local state before transition experimental: * happstack-state: now has experimental replication support using Amazon Web Services. This support is disabled by default. This feature is highly experimental, may not work, and may even be completely removed in future versions (though, hopefully not). THANKS: Alex Jacobson David Himmelstrup / Lemmih Matthew Elder / mae Antoine Latter Erik Hesselink Pasqualino 'Titto' Assini Nils / McManiaC Thomas Hartman Creighton Hogg / wchogg John MacFarlane Jochem Berndsen / koeien MightByte And everyone who filed bug reports, tested RC1 and RC2, and anyone else I missed.

6 7

Examples/docs for simulated annealing bindings
by Dougal Stanton 11 Feb '10

11 Feb '10

I found the HsASA library [1] on Hackage, but there's no documentation and it's not particularly intuitive. I can't see any obvious way of choosing initial config or generating new configurations. Google reveals no one using it. Does anyone have ideas? [1]: http://hackage.haskell.org/package/HsASA-0.1 Cheers, D -- Dougal Stanton dougal(a)dougalstanton.net // http://www.dougalstanton.net

3 2

SYB <<looping>> very, very mysteriously
by Jeremy Shaw 24 Jan '10

24 Jan '10

I have the following program which loops under GHC 6.10.4: http://www.hpaste.org/fastcgi/hpaste.fcgi/view?id=13561#a13561 {-# LANGUAGE DeriveDataTypeable, FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-} module Main where import qualified Data.Data as Data import Data.Typeable (Typeable) import Happstack.Data.Default import Data.Generics.SYB.WithClass.Basics import Data.Generics.SYB.WithClass.Instances () data Proposition = Proposition Expression deriving (Show, Data.Data, Typeable) data Expression = Conjunction (Maybe Expression) deriving (Show, Data.Data, Typeable) -- instance (Sat (ctx [Expression]), Sat (ctx Expression), Sat (ctx Proposition)) => Data ctx Proposition where instance Data DefaultD Proposition where gunfold _ k z c = case constrIndex c of 1 -> k (z Proposition) instance Default Proposition constrExpr :: Constr constrExpr = mkConstr dataTypeExpr "Conjuction" [] Prefix dataTypeExpr :: DataType dataTypeExpr = mkDataType "Expression" [constrExpr] instance ( Data ctx [Expression] , Sat (ctx Expression) , Sat (ctx (Maybe Expression))) => Data ctx Expression where {- instance Data DefaultD Expression where -} gunfold _ k z c = case constrIndex c of 1 -> k (z Conjunction) dataTypeOf _ _ = dataTypeExpr instance Default Expression e :: Expression e = defaultValueD dict main = print e I wish to explain the *many* ways in which it is mysterious. If you load the program into GHCi and evaluate 'e' it will hang. If you compile the program and run it, it will output <<loop>>. This behavior seems annoying, but not very weird. But, here is where it gets fun: 1. if you load the program into GHCi and eval 'e' it will hang. But, if you load the program and type, '(defaultValueD dict) :: Expression' at the prompt, it works fine! 2. if you remove the (Data DefaultD Proposition) instance, it works fine. (Even though Expression does not refer to Proposition in any way) 3. if you simply change the definition of 'gunfold' in the 'Data ctx Proposition' instance to, error "foo". The application works fine. That's right, if you change the body of a function that isn't even being called, evaluating 'e' starts working. (Even though Expression does not refer to Proposition in any way. And even though that gunfold instance is never actually called). 4. if you change the constraint on, Data ctx Expression, from (Data ctx [Expression]) to (Data ctx Expression) it works fine. (Or remove it all together). 5. if you change 'instance (Data DefaultD Proposition) where' to the line above it which is commented out, it works fine. 6. if you change the type of Proposition to, data Proposition = Proposition (Expression, Expression), then it works fine. So far I have only tested this in GHC 6.10.4. Any idea what is going on here? I can't imagine how changing the body of functions that aren't being called would fix things... - jeremy

3 5

ANN: atom-0.1.3
by Tom Hawkins 18 Jan '10

18 Jan '10

This release of Atom slightly changes the semantics of assertions and coverage. Assertion and coverage are now checked between the execution of every rule, instead of only when the rules containing assertions are fired. They are still subject to parental guard conditions, but not period or phase constraints. This means... period 20 $ atom "checkSomeStuff" $ do cond ok assert "A" a assert "B" b cover "C" c ... A, B, and C are checked all the time "ok" is true, not just every 20th cycle. Checking between every rule execution obviously impacts simulation time, but the increased testing rigor is worth it. I also added 'linear' to Common, which does linear interpolation and extrapolation on a line given two points. (I found I was replicating this function everywhere for sensor calibrations, control limits, etc.) http://hackage.haskell.org/package/atom

2 5

Data.Ring -- Pre-announce
by John Van Enk 16 Jan '10

16 Jan '10

Hi List, I recently needed a ring structure (circular list with bi-directional access) and didn't see anything obvious on Hackage. I threw something together fairly quickly and would like some feedback before tossing it on Hackage. I'd really appreciate if some one would: 1. make sure the code looks goodish (127 lines with full docs) 2. make sure my tests look saneish If I hear nothing, I'll assume wild support and push to Hackage. Code: http://github.com/sw17ch/data-ring/blob/master/src/Data/Ring.hs Tests: http://github.com/sw17ch/data-ring/blob/master/tests/quickcheck.hs Package Root: http://github.com/sw17ch/data-ring Thanks ahead of time, John Van Enk

16 25

FASTER primes (was: Re: Code and Perf. Data for Prime Finders (was: Genuine Eratosthenes sieve))
by Will Ness 16 Jan '10

16 Jan '10

apfelmus <apfelmus <at> quantentunnel.de> writes: > ~~ This is a repost, with apologies to anyone who sees this twice (I've replied to a two years old thread, and it doesn't show up in GMANE as I thought it would). ~~ > Dave Bayer wrote: > > What I'm calling a "venturi" > > > > venturi :: Ord a => [[a]] -> [a] > > > > merges an infinite list of infinite lists into one list, under the > > assumption that each list, and the heads of the lists, are in > > increasing order. > > > > I wrote this as an experiment in coding data structures in Haskell's > > lazy evaluation model, rather than as explicit data. The majority of the > > work done by this code is done by "merge"; the multiples of each prime > > percolate up through a tournament consisting of a balanced tree of > > suspended "merge" function calls. In order to create an infinite lazy > > balanced tree of lists, the datatype > > > > data List a = A a (List a) | B [a] > > > > is used as scaffolding. One thinks of the root of the infinite tree as > > starting at the leftmost child, and crawling up the left spine as > > necessary. > > After some pondering, the List a data structure for merging is really > ingenious! :) Here's a try to explain how it works: > > The task is to merge a number of sorted and infinite lists when it's > known that their heads are in increasing order. In particular, we want > to write > > primes = (2:) $ diff [3..] $ venturi $ map multiple primes > > Thus, we have a (maybe infinite) list > > xss = [xs1, xs2, xs3, ...] > > of infinite lists with the following properties > > all sorted xss > sorted (map head xss) > > where sorted is a function that returns True if the argument is a > sorted list. A first try to implement the merging function is > > venturi xss = foldr1 merge xss > = xs1 `merge` (xs2 `merge` (xs3 `merge` ... > > where merge is the standard function to merge to sorted lists. > > However, there are two problems. The first problem is that this doesn't > work for infinite lists since merge is strict in both arguments. But > the property head xs1 < head xs2 < head xs3 < ... we missed to exploit > yet can now be used in the following way > > venturi xss = foldr1 merge' xss > > merge' (x:xt) ys = x : merge xt ys > > In other words, merge' is biased towards the left element > > merge' (x:_|_) _|_ = x : _|_ > > which is correct since we know that (head xs < head ys). > > The second problem is that we want the calls to merge to be arranged > as a balanced binary tree since that gives an efficient heap. It's not > so difficult to find a good shape for the infinite tree, the real > problem is to adapt merge' to this situation since it's not associative: > > ...... > > The problem is that the second form doesn't realize that y is also > smaller than the third argument. In other words, the second form has to > treat more than one element as "privileged", namely x1,x2,... and y. > This can be done with the aforementioned list data structure > > data People a = VIP a (People a) | Crowd [a] > > The people (VIPs and crowd) are assumed to be _sorted_. Now, we can > start to implement > > merge' :: Ord a => People a -> People a -> People a Hi, ... replying to a two-years-old post here, :) :) and after consulting the full "VIP" version in haskellwiki/Prime_Numers#Implicit_Heap ... It is indeed the major problem with the merged multiples removing code (similar one to Richard Bird's code from Melissa O'Neill's JFP article) - the linear nature of foldr, requiring an (:: a->b->b) merge function. To make it freely composable to rearrange the list into arbitrary form tree it must indeed be type uniform (:: a->a->a) first, and associative second. The structure of the folded tree should be chosen to better suit the primes multiples production. I guestimate the total cost as Sum (1/p)*d, where p is a generating prime at the leaf, and d the leaf's depth, i.e. the amount of merge nodes its produced multiple must pass on its way to the top. The structure used in your VIP code, 1+(2+(4+(8+...))), can actually be improved upon with another, (2+4)+( (4+8)+( (8+16)+...)), for which the estimated cost is about 10%-12% lower. This can be expressed concisely as the following: primes :: () -> [Integer] primes () = 2:primes' where primes' = [3,5] ++ drop 2 [3,5..] `minus` comps mults = map (\p-> fromList [p*p,p*p+2*p..]) $ primes' (comps,_) = tfold mergeSP (pairwise mergeSP mults) fromList (x:xs) = ([x],xs) tfold f (a: ~(b: ~(c:xs))) = (a `f` (b `f` c)) `f` tfold f (pairwise f xs) pairwise f (x:y:ys) = f x y : pairwise f ys mergeSP (a,b) ~(c,d) = let (bc,b') = spMerge b c in (a ++ bc, merge b' d) where spMerge u@(x:xs) w@(y:ys) = case compare x y of LT -> (x:c,d) where (c,d) = spMerge xs w EQ -> (x:c,d) where (c,d) = spMerge xs ys GT -> (y:c,d) where (c,d) = spMerge u ys spMerge u [] = ([], u) spMerge [] w = ([], w) with ''merge'' and ''minus'' defined in the usual way. Its run times are indeed improved 10%-12% over the VIP code from the haskellwiki page. Testing was done by running the code, interpreted, inside GHCi. The ordered "split pairs" representing ordered lists here as pairs of a known, finite (so far) prefix and the rest of list, form a _monoid_ under mergeSP. Or with wheel, primes :: () -> [Integer] primes () = 2:3:5:7:primes' where primes' = [11,13] ++ drop 2 (rollFrom 11) `minus` comps mults = map (\p-> fromList $ map (p*) $ rollFrom p) $ primes' (comps,_) = tfold mergeSP (pairwise mergeSP mults) fromList (x:xs) = ([x],xs) rollFrom n = let x = (n-11) `mod` 210 (y,_) = span (< x) wheelSums in roll n $ drop (length y) wheel wheelSums = roll 0 wdiffs roll = scanl (+) wheel = wdiffs ++ wheel wdiffs = 2:4:2:4:6:2:6:4:2:4:6:6:2:6:4:2:6:4:6:8:4:2:4:2: 4:8:6:4:6:2:4:6:2:6:6:4:2:4:6:2:6:4:2:4:2:10:2:10:wdiffs Now _this_, when tested as interpreted code in GHCi, runs about 2.5x times faster than Priority Queue based code from Melissa O'Neill's ZIP package mentioned at the haskellwiki/Prime_Numbers page, with about half used memory reported, in producing 10,000 to 300,000 primes. It is faster than BayerPrimes.hs from the ZIP package too, in the tested range, at about 35 lines of code in total. ~~ This is a repost, with apologies to anyone who sees this twice (I've replied to a two years old thread, and it doesn't show up in GMANE as I thought it would). ~~

5 69

Arch Haskell News: Nov 23 2008
by Don Stewart 16 Jan '10

16 Jan '10

News about Haskell on Arch Linux * Arch now has 734 Haskell packages now * That’s an increase of 29 new packages in the last 8 days! * 3.6 new Haskell releases are occuring each day. Noteworthy, * haskell-hledger-0.2: “A ledger-compatible text-based accounting tool.” * gitit-0.3.1: “Wiki using HAppS, git, and pandoc.” * lhc-20081121: “Lhc Haskell Compiler” * haskell-hosc-0.6: “Haskell Open Sound Control” * haskell-flickr-0.3.2: “Haskell binding to the Flickr API” * haskell-delicious-0.3.2: “Accessing the del.icio.us APIs from Haskell (v2)” * haskell-mediawiki 0.2.3: “Interfacing with the MediaWiki API” * darcs-2.1.2.2: “a distributed, interactive, smart revision control system” Full update list, http://archhaskell.wordpress.com/2008/11/24/arch-haskell-news-nov-23-2008/ -- Don

24 56

How to fulfill the "code-reuse" destiny of OOP?
by Magicloud Magiclouds 13 Jan '10

13 Jan '10

Hi, I think when people talk about OOP, especially the inheriting, their focus mainly is on functions (methods). My concern here is about the data member inheriting. In OOP, when I inherit a class, I also got the members of it. But in haskell, how to inherit a "data"? -- 竹密岂妨流水过山高哪阻野云飞

19 27