- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] ANNOUNCE: dbus-core 0.5 and dbus-client 0.1
by John Millikin 03 Nov '09

03 Nov '09

The purpose behind the weird signature there is so that the computations in DBus.Bus can be passed directly to mkClient. Because of the design of dbus-client, you probably don't want to keep the connection around separately. ----- client <- mkClient getSessionBus ----- Here's a quick-and-dirty skeleton for sending notifications: ----- {-# LANGUAGE OverloadedStrings #-} import DBus.Bus import DBus.Client import DBus.Types -- Definition of notification object / interface notifications = Proxy (RemoteObject (mkBusName' "org.freedesktop.Notifications") (mkObjectPath' "/org/freedesktop/Notifications")) (mkInterfaceName' "org.freedesktop.Notifications") -- Callbacks; in real systems, these would probably be more complex onError x = putStrLn ("ERROR\n\n" ++ show x ++ "\n\n") onReturn x = putStrLn ("RETURN\n\n" ++ show x ++ "\n\n") -- A real library might accept additional parameters -- by the way: signature of Notify() is "susssasa{sv}i" notify c = call' params onError onReturn where params = [{- build parameters for your library here -}] call' = call client notifications (mkMemberName' "Notify") [] main = do client <- mkClient getSessionBus notify client {- main loop / mvar / whatever your library uses -} ----- On Tue, Nov 3, 2009 at 14:07, Max Rabkin <max.rabkin(a)gmail.com> wrote: > Hi John > > I'm trying to implement a pure Haskell library for notifications (like > libnotify). Unfortunately I don't know my way around dbus too well. > > Is there a reason for > > mkClient :: IO (Connection, BusName) -> IO Client > > instead of > > mkClient :: Connection -> IO Client > > ? > > mkClient simply discards the bus name, so in the event that one > doesn't have a bus name, one must create a fake one. Also, it executes > the IO action right away, so there is no need for it to take an IO > argument. All in all, this means I must write > > getClient = mkClient (flip (,) undefined <$> getSessionConnection) > > instead of > > getClient = mkClient =<< getSessionConnection. > > Perhaps you have a good reason for it? > > Regards, > Max > > On Fri, Oct 30, 2009 at 11:44 PM, John Millikin <jmillikin(a)gmail.com> wrote: >> These are pure-Haskell client libraries for using the D-Bus protocol. >> D-Bus is heavily used for inter-application IPC on Free and >> open-source desktop platforms, such as Linux, OpenSolaris, and >> FreeBSD. These libraries allow applications written in Haskell to >> inter-operate with other components of recent GNOME, KDE, and XFCE >> desktops. >> >> This is the first "real" release of these libraries; dbus-core has >> been published on Hackage for some time, but mostly just to make sure >> I got the Cabal bits right. I feel they are now stable / featureful >> enough for public use. >> >> Both are available on Hackage: >> >> http://hackage.haskell.org/package/dbus-core >> http://hackage.haskell.org/package/dbus-client >> >> --------- >> >> "dbus-core" is an implementation of the D-Bus protocol, specifically >> the parts relevant to clients. Eventually, it will probably grow some >> functions useful for implementing a message bus as well. It includes >> type mapping / conversion, an implementation of the wire format >> (marshaling / unmarshaling), data types for the currently defined >> message types (METHOD_CALL, METHOD_RETURN, ERROR, and SIGNAL) and a >> basic parser / generator for introspection documents. It is roughly >> equivalent in purpose to libdbus. >> >> By itself, a protocol implementation is somewhat cumbersome to use, so >> "dbus-client" is a high-level wrapper. It provides some abstractions >> like remote object proxies, exported object trees, synchronous method >> calls, signal reception, and name reservation. Messages are received >> and processed in separate IO threads, allowing asynchronous method >> call and signal handling. >> >> The purpose between splitting the library into two packages is >> stability; "dbus-core", ideally, will change only rarely -- >> performance improvements, new message / data types, etc. It provides a >> base level of functionality which more specialised libraries may use. >> "dbus-client" is an example of what such a library could look like, >> though for now it's not very Haskell-y (IO everywhere, exceptions, >> explicit locking). By separating the protocol from the client libs, >> alternative client libs can safely depend on the protocol >> implementation. >> >> --------- >> >> To see a sample of the library working, there's a clone of the >> "dbus-monitor" utility in <dbus-core/Examples>. Documentation is >> currently a bit lacking, so for now, the best documentation is the PDF >> of the source code itself, and the (rather barren) Haddock output: >> >> https://dl.getdropbox.com/u/1947532/dbus-core_0.5.pdf >> https://dl.getdropbox.com/u/1947532/dbus-core_0.5/index.html >> >> https://dl.getdropbox.com/u/1947532/dbus-client_0.1.pdf >> https://dl.getdropbox.com/u/1947532/dbus-client_0.1/index.html >> >> Once more people have used it without any major API issues, I'll write >> up a manual and populate the Haddock entries. >> >> Please respond with any feedback, difficulties, or suggestions. I'm >> particularly interested in ways to improve the public API, since I >> would rather make any breaking changes *before* anything big depends >> on these libraries. >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >> >

1 0

Re: Simple FAST lazy functional primes
by Steve 03 Nov '09

03 Nov '09

Hi Will, I had previously tested the Melissa O'Neil prime function (using the primes 0.1.1 package) and found it to be fast (for a functional approach), but with high memory use. To fully test a prime function, I think you should: 1. Test for more than the first 10^6 primes. Generating all primes to 10^6 is quite easy for modern computers. Most prime generating functions will run in less than 1 sec and look fast. Try generating all primes to 10^7 and 10^8 then you will see how 'fast' these lazy functional methods really are. 2. Measure memory use. As you move above 10^6 and test primes up to 10^7, 10^8, and 10^9, memory use becomes very important. A prime function with excessive memory use will soon consume all of the system's memory. Here's another primes function which performs quite well. primes :: [Int] primes = 2 : filter (isPrime primes) [3,5..] where isPrime (p:ps) n | mod n p == 0 = False | p*p > n = True | otherwise = isPrime ps n isPrime [] _ = False -- never used, but avoids compiler warning Here's some results from my PC, for generating primes to 10^8. 10**6 10**7 10**8 secs MiB secs MiB secs MiB ------------------------------- 1 0.01 0 0.1 2 2 14 2 0.56 7 11.1 43 270 306 3 0.61 7 11.8 44 260 342 4 0.43 36 5.4 345 900 not finished 1 using a Haskell ST Array 2 your primes function 3 my primes function, listed above 4 Melissa O'Neil method from primes 0.1.1 package To summarise the results from the tests I've run: - if you want fast functional primes, forget it, its not possible. - if you just want fast primes, then use C, or a Haskell array. - if performance does not matter and slow primes are acceptable, then use the purely functional approach. Regards, Steve

2 1

ANN: timeplot - a program for visualizing time series from log files
by Eugene Kirpichov 03 Nov '09

03 Nov '09

Hi. I've released timeplot on hackage: http://hackage.haskell.org/package/timeplot Timeplot is a program for visualizing time series from log files. The typical usage scenario: - Take a big log file of your program (100k-1m lines is OK) - Preprocess it with an awk one-liner to obtain a trace for timeplot - Plot the trace with timeplot, telling it which chart type (one of 8) to use for each "track" of the trace. For example, you can plot the frequencies of response times falling into 0..100ms, 100..500ms, 500..1000ms and >1000ms over 5-minute time intervals, or plot their 25% and 50% quantiles. - Behold the resulting graphics and discover anomalies and interesting process interdependencies in your program. Take a look at the description with lots of pretty pictures and a tutorial: http://www.haskell.org/haskellwiki/Timeplot -- Eugene Kirpichov Web IR developer, market.yandex.ru

1 0

Simple FAST lazy functional primes
by Will Ness 03 Nov '09

03 Nov '09

First, here it is: primes = 2: 3: sieve 0 primes' 5 primes' = tail primes sieve k (p:ps) x = [x | x<-[x,x+2..p*p-2], and [(x`rem`p)/=0 | p<-take k primes']] ++ sieve (k+1) ps (p*p+2) (thanks to Leon P.Smith for his brilliant idea of directly generating the spans of odds instead of calling 'span' on the infinite odds list). This code is faster than PriorityQueue-based sieve (granted, using my own ad-hoc implementation, so YMMV) in producing the first million primes (testing was done running the ghc -O3 compiled code inside GHCi). The relative performance vs the PQ-version is: 100,000 300,000 1,000,000 primes produced 0.6 0.75 0.97 I've recently came to the Melissa O'Neill's article (I know, I know) and she makes the incredible claim there that the square-of-prime optimization doesn't count if we want to improve the old and "lazy" uprimes = 2: sieve [3,5..] where sieve (p:xs) = p : sieve [x | x <- xs, x `mod` p > 0] Her article gave me the strong impression that she claims that the only way to fix this code is by using Priority Queue based optimization, and then goes on to present astronomical gains in speed by implementing it. Well, I find this claim incredible. First of all, the "naive" code fires up its nested filters much too early, when in fact each must be started only when the prime's square is reached (not only have its work started there - be started there itself!), so that filters are delayed: dprimes = 2: 3: sieve (tail dprimes) [5,7..] where sieve (p:ps) xs = h ++ sieve ps (filter ((/=0).(`rem`p)) (tail t)) where (h,t)=span (< p*p) xs This code right there is on par with the PQ-base code, only x3-4 slower at generating the first million primes. Second, the implicit control structure of linearly nested filters, piling up in front of the supply stream, each with its prime-number-it-filters-by hidden inside it, needs to be explicated into a data structure of primes-to-filter-by (which is in fact the prefix of the primes list we're building itself), so the filtering could be done by one function call instead of many nested calls: xprimes = 2: 3: sieve 0 primes' [5,7..] where primes' = tail xprimes sieve k (p:ps) xs = noDivs k h ++ sieve (k+1) ps (tail t) where (h,t)=span (< p*p) xs noDivs k = filter (\x-> all ((/=0).(x`rem`)) (take k primes')) >From here, using the brilliant idea of Leon P. Smith's of fusing the span and the infinite odds supply, we arrive at the final version, kprimes = 2: 3: sieve 0 primes' 5 where primes' = tail kprimes sieve k (p:ps) x = noDivs k h ++ sieve (k+1) ps (t+2) where (h,t)=([x,x+2..t-2], p*p) noDivs k = filter (\x-> all ((/=0).(x`rem`)) (take k primes')) Using the list comprehension syntax, it turns out, when compiled with ghc -O3, gives it another 5-10% speedup itself. So I take it to disprove the central premise of the article, and to show that simple lazy functional FAST primes code does in fact exist, and that the PQ optimization - which value of course no-one can dispute - is a far-end optimization.

5 14

Lecture Notes Advanced Functional programming available
by S. Doaitse Swierstra 03 Nov '09

03 Nov '09

I am happy to announce that the rworked lecture notes for the 6th Advance Functional programming summer school have become available. For further information about the lecture notes: http://www.springer.com/computer/programming/book/978-3-642-04651-3?cm_mmc=… Contents: • Umut Acar (Toyota Technological Institute, University of Chicago, USA): Self-Adjusting Computation • Richard Bird (University of Oxford, UK): Spider Spinning • Olivier Danvy (University of Aarhus, DK): On deriving abstract machines from interpreters and calculi • Johan Jeuring (Utrecht University, NL): Libraries for Generic Programming in Haskell • Ulf Norell (Chalmers University, SE): Dependently Typed Programming in Agda • Simon Peyton Jones and Satnam Singh (update) (Microsoft Research, UK): Parallel Functional Programming • Rinus Plasmeijer (Radboud University Nijmegen, NL): Specifying Interactive Workflows for the Web Doaitse

4 3

Applicative but not Monad
by Yusaku Hashimoto 03 Nov '09

03 Nov '09

Hello cafe, Do you know any data-type which is Applicative but not Monad? Cheers, -~nwn

18 28

ANN: BlogLiterately-0.2
by Robert Greayer 03 Nov '09

03 Nov '09

Due to overwhelming popular demand*, BlogLiterately (version 0.2) has been released on Hackage. It's a simple tool for uploading posts written in markdown and (optionally) literate Haskell to web logs. It relies heavily on Pandoc for markdown processing, but adds a few twists like syntax highlighting via hscolour. The original version was described here: http://greayer.wordpress.com/2009/10/26/blogging-literately-in-haskell/ The new version (the first version on hackage) has been updated a bit -- to take advantage of Pandoc highlighting extensions and to support blog categories, mainly. The primary documentation is just the haskell package page: http://hackage.haskell.org/package/BlogLiterately It's only been tested with a WordPress blog (mine) but ought to work with any blogging software that supports the MetaWeblog API. Send bug reports, etc. to me... Thanks! * -- 2 people asked

1 0

How to convert records into Haskell structure in Haskell way?
by Magicloud Magiclouds 03 Nov '09

03 Nov '09

Hi, Say I have something like this: [ Record { item = "A1", value = "0" } , Record { item = "B1", value = "13" } , Record { item = "A2", value = "2" } , Record { item = "B2", value = "10" } ] How to convert it into: [ XXInfo { name = "A", value1 = "0", value2 = "2" } , XXInfo { name = "B", value1 = "13", value2 = "10" } ] If XXInfo has a lot of members. And sometimes the original data might be not integrity. -- 竹密岂妨流水过山高哪阻野云飞

4 4

advice for dispatch question
by John Lato 03 Nov '09

03 Nov '09

Hello, I've been thinking about a problem recently, and would like to know if there are any recommendations for a solution. I have two container-like type classes, defined as follows: > import Control.Monad > > type family ElemOf c :: * > type family MonadOf c :: * -> * > > class PureContainer c where > chead :: c -> ElemOf c > > class MonadicContainer c where > mhead :: c -> MonadOf c (ElemOf c) now suppose I have two functions, like this: > pureOp :: (PureContainer c, Monad m) => c -> m () > pureOp c = doSomethingWithElem $ chead c > > monadOp :: (Monad (MonadOf c), MonadicContainer c) => c -> MonadOf c () > monadOp c = mhead c >>= doSomethingWithElem > > -- assume this function does something > doSomethingWithElem :: Monad m => a -> m () > doSomethingWithElem _ = return () the goal is to take the head from either a PureContainer or a MonadicContainer and feed it to the doSomethingWithElem function, which we can assume does something monadic. What I would like to do would be write one function that behaves like this quasi-Haskell: combinedOp :: c -> m () combinedOp | PureContainer c = doSomethingWithElem $ chead c combinedOp | MonadicContainer c = mhead c >>= doSomethingWithElem I have many functions under consideration, and it would be nice to not have to duplicate all of them. So far I've thought of two possible solutions: 1. create a newtype > newtype M s (m :: * -> *) = M{ unM :: s} then I can write > type instance ElemOf (M c m) = ElemOf c > type instance MonadOf (M c m) = m > > instance (Monad m, PureContainer c) => MonadicContainer (M c m) where > mhead = return . chead . unM In this case, I would ignore the PureContainer case of combinedOp and just stick every PureContainer of interest into the newtype as necessary. 2. Use a GADT with two constructors to special-case appropriately. I think this should work, but haven't tried it yet. It seems more complicated, and less transparent, than using a newtype as above. Does anyone have any advice for this situation? I'm defining PureContainer instances anyway, so it seems silly to have to duplicate everything for the monadic case. Likewise the MonadicContainer version is highly desirable for certain types, so I don't want to forgo that either. Thanks, John

1 0

Re: Suggested algorithm to control upper bound of space "leaks"
by Shelby Moore 02 Nov '09

02 Nov '09

http://www.haskell.org/pipermail/cvs-ghc/2009-October/050928.html Shelby Moore wrote: > One possible runtime optimization to provide an upper bound for cache > control, might be to not cache thunks when the runtime computation time > times number of cache hits, is less than the round-trip paging time > multiplied by recent system paging load. > > Is this novel? Is it useful? Clarify and improve: One possible idea for runtime optimization to provide a more deterministic upper bound on paging load for cache control, might be to not cache thunk-wise when for each thunk, the total tree of computation time under the thunk multiplied by the number of cache hits on the thunk, is less than the round-trip paging time of thunks under the tree multiplied by a chosen factor of recent system paging load. Or toggle the test on and off on a chosen threshold of recent system paging load. Obviously "heap size" could be substituted for "paging load", but my goal is to make the optimization resolution independent, i.e. orthogonal to system configuration such as RAM size, speed, virtual media size, algorithm, etc.. The "catch-22" of the idea if any, probably derives from the permutations of computation time from the lazy computation of thunks under the tree? Note I realize this list is probably not the correct place to discuss research. I do not have time to do this research. Any suggestion where I could post or send this idea so people interested in this type of research could see it? Add a feature request to GHC bug tracker? To the general Haskell mailing list?

1 4

Haskell Weekly News: Issue 137 - October 31, 2009
by jfredett＠gmail.com 02 Nov '09

02 Nov '09

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20091031 Issue 137 - October 31, 2009 --------------------------------------------------------------------------- Welcome to issue 137 of HWN, a newsletter covering developments in the [1]Haskell community. This week brings a new release of xmonad, some cool bindings to allow interaction with GNOME, KDE, and XFCE desktops and a new version of haskell-mode for the lesser of two editors... Some progress has also been made on the new HWN software, though this was mitigated by the fact that I started playing with the Isabelle theorem prover (after reading about Haskabelle) and so now I find myself convinced I should formally prove all of my software, and also that I'm pretty much incapable of getting things done when cool tools present themselves. In fact, I don't think I'll even be able to finish this [2]editori* [3]Exception: The Haskell Weekly News! Announcements xmonad 0.9 is now available! Don Stewart [4]announced a new version of everyone's favorite Tiling Window Manager, xmonad! The changes and improvments are too numerous to mention, see the post for details! WFLP2010 2nd CFP: LNCS + invited speaker + abstract due Nov 9. Pablo Nogueira [5]announced a second call for papers for the Workshop on Functional and Constraint Logic Programming. dbus-core 0.5 and dbus-client 0.1. John Millikin [6]announced pure-Haskell client libraries for using the D-Bus protocol. D-Bus is heavily used for inter-application IPC on Free and open-source desktop platforms, such as Linux, OpenSolaris, and FreeBSD. These libraries allow applications written in Haskell to inter-operate with other components of recent GNOME, KDE, and XFCE desktops. Singapore Functional Programmer Group First Meetup. Kenny Lu [7]announced (with apologies for the late notice) an informal meeting for the Functional Programmer Group in Singapore on 2 Nov 2009. The theme for the first meeting will be 'meet and greet'. GeBoP 1.7. Henk-Jan van Tuyl [8]updated and cabalized GeBoP (the General Boardgames Player) and uploaded it to hackage. GPS package on Hackage. Thomas DuBuisson [9]announced that he fixed up the GPS package to add correct distance calculation and a separate module for exporting KML. GPipe-TextureLoad 1.0.0 and GPipe 1.0.3. Tobias Bexelius [10]announced a new version of GPipe as well as a utility package for loading textures. HoleyMonoid-0.1. Martijn van Steenbergen [11]announced announce the first release of HoleyMonoid, a datatype that helps you build monoids with holes in them. The holes are filled in later using normal function application. GlomeVec, IcoGrid. Jim Snow [12]announced a couple of packages, GlomeVec is a vector library used in Jim's ray-tracer, and IcoGrid is a library for dealing with grids of hexagons and pentagons wrapped on a sphere. attempt-0.0.0. Michael Snoyman [13]announced a new package for exceptions haskell-mode 2.5. Svein Ove Aas [14]announced a new version of haskell-mode for that other 'editor'... Discussion Applicative but not Monad. Yusaku Hashimoto [15]asked about an example of a datatype that was an instance of Applicative, but not an instance of Monad. AND/OR Perceptron. Hector Guilarte [16]asked about how to understand a particular portion of JP Moresmau's [17]Perceptron in Haskell What is the current state of affairs with supercompilation? Eugene Kirpichov [18]asked about supercompilation in Haskell. Blog noise [19]Haskell news from the [20]blogosphere. Blog posts from people new to the Haskell community are marked with >>>, be sure to welcome them! * Magnus Therning: [21]Playing with sockets in Haskell. * Holumbus: [22]Switched to Git. * Manuel M T Chakravarty: [23]Finally found the ghci bug on Snow Leopard. * Galois, Inc: [24]Tech Talk: Testing First-Order-Logic Axioms in AutoCert. * Brent Yorgey: [25]Collecting Attributes. * Darcs: [26]darcs weekly news #44. * FP Lunch: [27]Parser Combinators are as expressive as possible. * David Amos: [28]Simple groups, the atoms of symmetry. * Xmonad: [29]xmonad 0.9 available now!. * Michael Snoyman: [30]Introduction to attempt error reporting library. * FP-Syd: [31]Sydney FP Group: FP-Syd #20.. Quotes of the Week * hexpuem: [on learning haskell] the best way is to shove a SD card up your nose with learn yourself a haskell good on it * copumpkin: copumpkin: 'YOU ARE SUCH A PULLBACK' copumpkin: 'YOU KNOW WHAT? I FUNCTORED YOUR MOTHER LAST NIGHT' * saml and mauke: saml: 'How can I convert python file to haskell?' mauke: 'By piping it through a programmer' * monochrom: premature generality is the root of OOP * EvilTerran: {-# LANGUAGE FlexibleMorals #-} -- needed for unsafeLaunchMissiles * Warrigal: Hey, the module loaded. I didn't expect that. * lilac: class Monad m where return and Kleisli compose must form a monoid About the Haskell Weekly News New editions are posted to [32]the Haskell mailing list as well as to [33]the Haskell Sequence and [34]Planet Haskell. [35]RSS is also available, and headlines appear on [36]haskell.org. To help create new editions of this newsletter, please see the information on [37]how to contribute. Send stories to jfredett . at . gmail . dot . com. The darcs repository is available at darcs get [38]http://patch-tag.com/r/jfredett/HWN2/pullrepo HWN2 . References 1. http://haskell.org/ 2. http://uncyclopedia.wikia.com/wiki/Haskell 3. http://www.reddit.com/r/haskell/comments/9yt9m/haskell_is_an_obscure_and_mo… 4. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65286 5. http://article.gmane.org/gmane.comp.lang.haskell.general/17596 6. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65436 7. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65406 8. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65384 9. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65326 10. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65320 11. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65311 12. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65294 13. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65281 14. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65268 15. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/65418 16. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/65393 17. http://jpmoresmau.blogspot.com/2007/05/perceptron-in-haskell.html 18. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/65227 19. http://planet.haskell.org/ 20. http://haskell.org/haskellwiki/Blog_articles 21. http://therning.org/magnus/archives/778 22. http://holumbus.fh-wedel.de/blog/?p=25 23. http://justtesting.org/post/227629236 24. http://www.galois.com/blog/2009/10/28/ahn-autocert/ 25. http://byorgey.wordpress.com/2009/10/28/collecting-attributes/ 26. http://blog.darcs.net/2009/10/darcs-weekly-news-44.html 27. http://sneezy.cs.nott.ac.uk/fplunch/weblog/?p=271 28. http://haskellformaths.blogspot.com/2009/10/simple-groups-atoms-of-symmetry… 29. http://xmonad.wordpress.com/2009/10/26/xmonad-0-9-available-now/ 30. http://blog.snoyman.com/2009/10/25/introduction-to-attempt-error-reporting-… 31. http://www.mega-nerd.com/erikd/Blog/FP-Syd/fp-syd-20.html 32. http://www.haskell.org/mailman/listinfo/haskell 33. http://sequence.complete.org/ 34. http://planet.haskell.org/ 35. http://sequence.complete.org/node/feed 36. http://haskell.org/ 37. http://haskell.org/haskellwiki/HWN 38. http://patch-tag.com/r/jfredett/HWN2/pullrepo%20HWN2

5 4

Hackage still down?
by Magnus Therning 02 Nov '09

02 Nov '09

It seems to have been down for at least the better part of today. Is it something worth worrying about? /M -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus＠therning．org Jabber: magnus＠therning．org http://therning.org/magnus identi.ca|twitter: magthe

3 3

Experiments with defunctionalization, church-encoding and CPS
by Eugene Kirpichov 02 Nov '09

02 Nov '09

I took a toy problem - find the first node satisfying a predicate in a binary tree, started with a naive Maybe-based implementation - and experimented with 3 ways of changing the program: - Church-encode the Maybe - Convert the program into CPS - Defunctionalize the Church-encoded or CPS-transformed program http://hpaste.org/fastcgi/hpaste.fcgi/view?id=10686 The link points to code, a benchmark and conclusion. Conclusion: - Haskell implements Maybe well enough that it is not possible to do better - Defunctionalization and consequent optimization yields same performance as the one with Maybe - Non-simplified CPS and Church-encoded representations do bad -- Eugene Kirpichov Web IR developer, market.yandex.ru

4 6

Using HaskellDB on Tables that contain same column names
by R. Emre Başar 02 Nov '09

02 Nov '09

Hi all, I'm trying to create a HaskellDB application for keeping the inventory of a set of devices. My database includes some tables which have some columns with same names. Here is an example: Server: id, name, vendor (fk), model(fk), system_id (always null) Vendor: id, name Model: id, name I'm trying to join those three tables and create a result that contains the names of the server, vendor and model. I use the projection: project (Server.name << s!Server.name # Vendor.name << v!Vendor.name # Model.name << m!Model.name # Server.system_id << s!Server.system_id) When I execute the query, the result contains just the name of the servers repeated three times. When I check the generated SQL, I see that it generates not what I expected. Am I missing something here? If you need, I can put the full source & generated SQL to somewhere. -- R. Emre Başar İstanbul Bilgi University Department of Computer Science

2 1

AND/OR Perceptron
by Hector Guilarte 02 Nov '09

02 Nov '09

Hi cafe, I'm trying to implement a Perceptron in Haskell and I found one in: http://jpmoresmau.blogspot.com/2007/05/perceptron-in-haskell.html (Thanks JP Moresmau) but there is one line I don't understand, I was wondering if someone could explain it to me. I know the theory behind a perceptron, my question is more about the Haskell syntax in that line I don't understand. epoch :: [([Float],Float)] -> -- ^ Test Cases and Expected Values for each test case [Float] -> -- ^ weights ([Float],Float) -- ^ New weights, delta epoch allInputs weights= let f w (inputs,expected) = step inputs w expected -- I don't understand this line newWeights = foldl f weights allInputs -- Neither this one delta = (foldl (+) 0 (map abs (zipWith (-) newWeights weights))) / (fromIntegral $ length weights) in (newWeights,delta) What is f and what is w? I really don't get it, Is like it is defining a function f which calls step unziping the input, taking one of the elements from the fst and it's corresponding snd and invoking step with that, along with w (which seems to be a list according to step's signature but I don't know where it comes from), and then applying fold to the weights and all the Inputs using that f function... But I don't get it! Maybe if someone could rewrite that redefining f as an separate function and calling fold with that function I'll get it. The input for epoch would be something like this: epoch [([0,0],0),([0,1],0),([1,0],0),([1,1],1)] [-0,413,0.135] and the output for that examples is: ([0.0,412.9],3.333537e-2) Thanks a lot, Hector Guilarte

4 5

hackage is down.
by Thomas Hartman 02 Nov '09

02 Nov '09

http://hackage.haskell.org

9 11

Bulding a library for C users on OS X
by Chris Eidhof 02 Nov '09

02 Nov '09

Hey all, I'm trying to call a Haskell function from C, on OS X. There's an excellent post [1] by Tomáš Janoušek that explains how to do this on Linux. However, on OS X, it's different. First of all, it looks like the -no-hs-main flag is ignored, because I get the following error: > ghc -O2 --make -no-hs-main -optl '-shared' -optc '- DMODULE=Test' -o Test.so Test.hs module_init.c > [1 of 1] Compiling Main ( Test.hs, Test.o ) > > Test.hs:1:0: The function `main' is not defined in module `Main' Second, I learned [2] that I have to pass in different flags on OS X, but unfortunately, GHC still wants me to have main. I'm probably doing something wrong here, is there anyone who can give me some pointers? (no pun intended). I'm running GHC 6.10.2 on Leopard. Thanks, -chris [1]: http://blog.haskell.cz/pivnik/building-a-shared-library-in-haskell/ [2]: http://www.mail-archive.com/haskell-cafe@haskell.org/msg51303.html

3 3

Re: [Haskell-cafe] hackage is down.
by scooter.phd＠gmail.com 02 Nov '09

02 Nov '09

Untenable for many "corporate" users administratively prohibited from running any P2P software. First really creative use of a DHT I've seen in 6 years, kudos. ------Original Message------ From: Shelby Moore Sender: haskell-cafe-bounces(a)haskell.org To: haskell-cafe(a)haskell.org ReplyTo: shelby(a)coolpage.com Subject: Re: [Haskell-cafe] hackage is down. Sent: Nov 1, 2009 19:57 Opportunity cost minimization problem: >> No no no! Why not download the normal (signed) cabal list from the >> DHT (and optionally directly from hackage.haskell.org)? These are all >> the packages that would appear on the website. Why serve any other >> content? All nodes in the DHT may check and make sure the file (or >> fragment) being served is properly signed. >> >> Any desire for popularity or tagging capability should be separate. >> > Because single single hackage private key can be bruteforsed or stolen > far easier than lots and lots keys of random people. > > > >>> + User maintains list of trusted people's open keys, in order to >>> validate authenticity and see trusted ratings. >> >> This would need further explanation, but in general I'm against >> requiring user interaction on this level. > You choose who's moderating packages for you. Some well-known community > moderators and your trusted friends. If no one rated package yet, then > you download and rate, so people who trust you can make decision based > on your rate. > Kind of social network. In short, P2P introduces non-determinism. Non-determinism is natural law and otherwise order is not permanent (e.g. ends in non-composability, errors, vulnerabilities, etc): http://www.haskell.org/pipermail/haskell-cafe/2009-November/068432.html What is needed is some way to set up upper bound to the level of non-determinism in some useful domain: http://www.haskell.org/pipermail/haskell-cafe/2009-October/068382.html (space determinism in Haskell) Which are really opportunity cost minimizations: http://forum.bittorrent.org/viewtopic.php?id=28 (my architectural comments about BitTorrent free loading) http://goldwetrust.up-with.com/technology-f8/computers-t112-15.htm#2189 (long winded, not so coherent brainstorming) _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe Sent from my Verizon Wireless BlackBerry

1 0

ghci REPL output under Haskell Platform on Mac OS X
by Mark Lentczner 01 Nov '09

01 Nov '09

My ghci installation has a very annoying behavior: When it takes input, the result is displayed on the same line as the input, overwriting the prompt and input. Viz.: [1015] : ghci GHCi, version 6.10.4: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer ... linking ... done. Loading package base ... linking ... done. 7relude> 3 + 4 Prelude> Note the 7 that overwrites the P in Prelude. I have had several prior versions of ghci installed, most recently 6.10.1, and they never had this problem. (In other words, I saw: Prelude> 3 + 4 7 Prelude> Those prior gchi's were installed from the GHC binaries. Most recently I decided to give Haskell Platform a try, and I installed that. That is the point at which this behavior started. My environment: Haskell Platform 2009.2.0.2 GHC 6.10.4 (installed w/Haskell Platform) Mac OS X 10.6.1 Oddly, I have GHC 6.10.4 installed from GHC binaries on a Mac OS X 10.5 machine at work, and the newline behavior is correct. So the issue could be Haskell Platform vs. GHC installs... or it could be 10.5 vs. 10.6 Anyone seen anything like this? - Mark

2 2

hSeek in Windows
by Philippos Apolinarius 01 Nov '09

01 Nov '09

As many people guess, I am trying to port programs from Clean 1.3 to Haskell (and also to Clean 2.2, which is easier, but not much easier). Late Professor Wellesley wrote an interesting data base manager in Clean 1.3 that I would like to see in Haskell and Clean 2.2. However, when I tried to implement the BTree algorithm, GHC compiler did not accept hSeek and other IO operations. D:\Programs\GHC-PROGS\docs\textut>ghc btree.hs --make [1 of 1] Compiling Main ( btree.hs, btree.o ) Linking btree.exe ... D:\Programs\GHC-PROGS\docs\textut>btree.exe btree.exe: teste.txt: hSeek: illegal operation (seek operations on text-mod dles are not allowed on this platform) To make a long story short, the program compiles, but does not run. This is interesting, because when Clean compiles an input/output operation it certainly executes it. In any case, what I should do in order to make file operations work on Windows? I need random access to text files. __________________________________________________________________ Yahoo! Canada Toolbar: Search from anywhere on the web, and bookmark your favourite sites. Download it now http://ca.toolbar.yahoo.com.

3 2

Calling Haskell from C, Linking with gcc?
by John Velman 01 Nov '09

01 Nov '09

I think if I knew which libraries to add to the gcc link, I could make this work, but can't seem to find out from the documentation. Here are more specifics: I'd like to build a Cocoa program on OS X with the Aqua user interface using Xcode, but using a Haskell module with functions accessed through the foreign export interface. In fact this seems to fit in well with the Apple Model-View-Control programming pattern, with Haskell implementation of the Model, maybe some of the Control, and Cocoa implementation of the View and some of the Control. I've put together a short program (from the Wiki calling Haskell from C example) and compiling and linking with ghc it runs as advertised. As an experiment, I put the c main program into an Xcode project, added the haskell module .o and stub.o, stub.h files. Also added the HsFFI.h. Then did a build and run. As expected I got a bunch of missing entry points (26, if I recall correctly). Adding libffi.a and libHSrts.a brings me up to 56 missing entry points. Searching the other lib files for these seems pretty hopeless. Any pointers to documentation, or other help will be greatly appreciated! Thanks, John Velman

6 12

Newcomers question
by b1g3ar5 01 Nov '09

01 Nov '09

I'm trying: instance Num b => Num (a -> b) where fromInteger = pure . Prelude.fromInteger negate = fmap Prelude.negate (+) = liftA2 (Prelude.+) (*) = liftA2 (Prelude.*) abs = fmap Prelude.abs signum = fmap Prelude.signum but the compiler rejects it with: src\Main.hs:24:9: Could not deduce (Show (a -> b), Eq (a -> b)) from the context (Num b) arising from the superclasses of an instance declaration at src\Main.hs:24:9-29 Possible fix: add (Show (a -> b), Eq (a -> b)) to the context of the instance declaration or add an instance declaration for (Show (a -> b), Eq (a -> b)) In the instance declaration for `Num (a -> b)' Could someone please explain this to me? I thought that it might be that it couldn't work out the functions necessary for (a->b) to be in the classes Show and Eq - so I tried adding definitions for == ans show, but it made no difference. Thanks

5 5

Re: [Haskell-cafe] ANN: mecha-0.0.2
by Tom Hawkins 01 Nov '09

01 Nov '09

> Neat! What a cool idea. > >> data Solid = Solid (Vector -> Bool) > > With a type like this, how is it possible to make solids without hard edges? Now the only way is to create a new primitive. In the future I want to have blended versions of the set operations to apply fillets or bevels at the joints. But I'm not sure how to do this yet. > Why did you choose a monadic interface? Is there a technical or > semantic problem with a statement like: I was originally thinking a monad would be needed to prevent re-meshing difference instances of the same solid, as well has to generate a bill-of-materials, 2D prints, etc. But you're right, I don't think it's needed. Thanks. See mecha-0.0.2: example :: IO () example = view design design :: Asm design = assemble [ color (0, 0, 0.8) $ place 1 0.06 8 $ difference sphereCube cyl3 , move (-4, 0, 0) $ color (0.8, 0, 0) $ place 1 0.08 8 $ sphereCube , move ( 0, 4, 0) $ color (0, 0.8, 0) $ place 1.5 0.08 8 $ cyl3 ] sphereCube = intersection sphere $ scaleXYZ 0.75 cube cyl = scale (0.5, 0.5, 1.2) $ cylinder cyl3 = unions [cyl, rotateX (pi / 2) cyl, rotateY (pi / 2) cyl]

2 1

Monad Comprehensions
by Günther Schmidt 01 Nov '09

01 Nov '09

Hi all, once again I find myself merely scratching the surface of the power of Haskell, which is exciting and frustrating at the same time. While real world demands require me to find / develop solutions quickly (abstractions for querying data sets) I keep catching glimpses of all this power. But for someone like me it's difficult to assess from these glimpses alone which to study first. In the last few weeks I kept bugging people here on this list about DSLs, so I could create my own to express queries / relational algebra. I'd later choose then to compile this to SQL or to in-memory code. Next thing I notice that I've overlooked list comprehension all this time, which already express quite a lot of what I'd need. And then, on top of it all, monad comprehension, or rather monads period. The thing that particularly set me off was a video from Dan Piponi: http://vimeo.com/6590617 It certainly made me realize how little I have understood how much power merely monads give you. In short, I'm truly lost. If anyone else, with roughly the same starting point as me, has found their way through this jungle I'd certainly appreciate some tips. In particular I wonder if someone has been able to follow what Dan demonstrates in this video, or was it a jaw-dropping experience for everyone else just as me? Günther

1 0

ANNOUNCE: dbus-core 0.5 and dbus-client 0.1
by John Millikin 01 Nov '09

01 Nov '09

These are pure-Haskell client libraries for using the D-Bus protocol. D-Bus is heavily used for inter-application IPC on Free and open-source desktop platforms, such as Linux, OpenSolaris, and FreeBSD. These libraries allow applications written in Haskell to inter-operate with other components of recent GNOME, KDE, and XFCE desktops. This is the first "real" release of these libraries; dbus-core has been published on Hackage for some time, but mostly just to make sure I got the Cabal bits right. I feel they are now stable / featureful enough for public use. Both are available on Hackage: http://hackage.haskell.org/package/dbus-core http://hackage.haskell.org/package/dbus-client --------- "dbus-core" is an implementation of the D-Bus protocol, specifically the parts relevant to clients. Eventually, it will probably grow some functions useful for implementing a message bus as well. It includes type mapping / conversion, an implementation of the wire format (marshaling / unmarshaling), data types for the currently defined message types (METHOD_CALL, METHOD_RETURN, ERROR, and SIGNAL) and a basic parser / generator for introspection documents. It is roughly equivalent in purpose to libdbus. By itself, a protocol implementation is somewhat cumbersome to use, so "dbus-client" is a high-level wrapper. It provides some abstractions like remote object proxies, exported object trees, synchronous method calls, signal reception, and name reservation. Messages are received and processed in separate IO threads, allowing asynchronous method call and signal handling. The purpose between splitting the library into two packages is stability; "dbus-core", ideally, will change only rarely -- performance improvements, new message / data types, etc. It provides a base level of functionality which more specialised libraries may use. "dbus-client" is an example of what such a library could look like, though for now it's not very Haskell-y (IO everywhere, exceptions, explicit locking). By separating the protocol from the client libs, alternative client libs can safely depend on the protocol implementation. --------- To see a sample of the library working, there's a clone of the "dbus-monitor" utility in <dbus-core/Examples>. Documentation is currently a bit lacking, so for now, the best documentation is the PDF of the source code itself, and the (rather barren) Haddock output: https://dl.getdropbox.com/u/1947532/dbus-core_0.5.pdf https://dl.getdropbox.com/u/1947532/dbus-core_0.5/index.html https://dl.getdropbox.com/u/1947532/dbus-client_0.1.pdf https://dl.getdropbox.com/u/1947532/dbus-client_0.1/index.html Once more people have used it without any major API issues, I'll write up a manual and populate the Haddock entries. Please respond with any feedback, difficulties, or suggestions. I'm particularly interested in ways to improve the public API, since I would rather make any breaking changes *before* anything big depends on these libraries.

2 1

ATTN: Singapore based Haskellers - Singapore FP Users Group First Meeting
by Max Cantor 01 Nov '09

01 Nov '09

We are organizing a Functional Programming Users Group in Singapore and our first meeting is Monday, November 2nd at 6 pm. We will meet initially in the Lobby of 8 Shenton Way. Map: http://bit.ly/1PzqlB -or- http://maps.google.com/maps?f=q&source=s_q&hl=en&geocode=&q=8+Shenton+Way,+… If you have any trouble, please feel free to call me at +65-9329-6139 Max

1 0

The (>|) function in Control.Parallel.Strategies
by Wei Hu 01 Nov '09

01 Nov '09

The documentation of (>|) says that it "evaluates the first argument before the second". The function is defined as (http://www.haskell.org/ghc/docs/6.10-latest/html/libraries/parallel/src/Con…) (>|) :: Done -> Done -> Done {-# INLINE (>|) #-} (>|) = Prelude.seq I'm curious why it's defined as Prelude.seq, instead of pseq? The semantics seems to require pseq here. I also found the following comment that doesn't make sense to me: The operators >| and >|| are alternative names for `seq` and `par`. With the introduction of a Prelude function `seq` separating the Prelude function from the Strategy function becomes a pain. The notation also matches the notation for strategic function application.

1 0

ANN: mecha-0.0.1
by Tom Hawkins 31 Oct '09

31 Oct '09

Mecha is a little solid modeling language intended for machine design. Mecha has two layers: a pure functional layer for defining solids (aka. parts), and a monadic layer for arranging parts into assemblies. Solids (parts) are built using set operations on solid primitives. A solid primitives is simply a predicate that says whether a point in space is inside the solid: data Solid = Solid (Vector -> Bool) Mesh generation is performed by adaptive marching cubes. It's slow, especially if you don't have graphics hardware. And solids with hard edges don't render very clean. But the basics work. Here's a simple example: example :: IO () example = view design design :: Asm () design = do a <- part 1 0.06 8 $ difference sphereCube cyl3 b <- part 1 0.08 8 $ sphereCube c <- part 1.5 0.08 8 $ cyl3 color (0, 0, 0.8) $ place a move (-4, 0, 0) $ color (0.8, 0, 0) $ place b move ( 0, 4, 0) $ color (0, 0.8, 0) $ place c sphereCube = intersection sphere $ scaleXYZ 0.75 cube cyl = scale (0.5, 0.5, 1.2) $ cylinder cyl3 = unions [cyl, rotateX (pi / 2) cyl, rotateY (pi / 2) cyl] Screenshot: http://tomahawkins.org/ Enjoy!

2 1

ANN: Advgame 0.1.1
by Tim Wawrzynczak 31 Oct '09

31 Oct '09

Hey cafe, If any of you were (or are) Common Lispers, you may be aware of Dr. Conrad Barski's humorous and lighthearted approach to Common Lisp. As a little tribute to his CL evangelization efforts, I ported his tutorial, 'Casting SPELs in Lisp' (http://www.lisperati.com/casting.html) to Haskell. It works very similarly to his final program, except it can be run in a loop, instead of one function at a time. It's available at http://hackage.haskell.org/package/Advgame-0.1.1 if anyone is interested. Cheers, - Tim

1 0

I read somewhere that for 90% of a wide class of computing problems, you only need 10% of the source code in Haskell, that you would in an imperative language.
by Shelby Moore 31 Oct '09

31 Oct '09

I found the post at the following link to be the most useful in explaining declarative versus imperative: http://www.haskell.org/pipermail/haskell-cafe/2009-September/067000.html Here follows what I want to add to the discussion: http://www.haskell.org/pipermail/haskell-cafe/2009-September/067094.html John Dorsey wrote: >> Well, try this: Go ask a random person how you add up a list of numbers. >> Most of them will say something about adding the first two together, >> adding the third to that total, and so forth. In other words, the step >> by step instructions. > > You word the (hypothetical) question with a bias toward imperative > thinking. You're asking "How do you do this action?" > Why isn't the question "What is the sum of a list of numbers?", > which is biased toward the declarative? Instead ask "How do you add some numbers?" Then you will more likely get the answer, "add them together". The disconnect is that most people do not think in terms of details, so if you ask them to think in terms of how to declare "the order of the operation over the set in minimized semantics", you will push them into an area which they are not specialized. I have read the claim that Haskell tends to attract some of the most talented programmers, because it resonates with the mindset of people who like to generalize details into minimum rulesets. The most accurate question should be, "How do you add some numbers with minimized instructions?", because it forces them to realize they must order the set. An answer might be, "Zero if empty, else order the set, sum the first number with the sum of remainder of the set. Repeat for the sum of remainder." The real leap for me (not using my college math recently), and I am sure for most imperative programmers and people in general, is go from the recursive declaration above, to the notion that the declaration __IS__ the sum and does not just _return_ or output the sum. That notion becomes important when the declaration is not a single number result, instead a set. That is important because there is no way to _return_ an infinite set. The mind gets stuck on the recursive declaration of infinite sets, such as fibonacci, unless one comes from a mathematical mindset. Math is a muscle, it atrophies if you do not exercise it. And similarly to competitive muscles and aerobic capacity (speaking from my own experience), it only takes a little bit of exercise to get back to about 60% of former peak ability after a long period of no exercise.

1 1

GHC core packages: same core?
by Dimitry Golubovsky 31 Oct '09

31 Oct '09

Hi, Just curious whether package http://hackage.haskell.org/package/ghc-core and http://hackage.haskell.org/package/extcore operate on the same flavor of GHC Core? There seem to be external [1] and internal [2] flavors of GHC Core. [1] http://www.haskell.org/ghc/docs/6.10.2/html/ext-core/core.pdf [2] http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/CoreSynType Thanks. -- Dimitry Golubovsky Anywhere on the Web

4 5

uu-parsinglib pKeyword
by Ozgur Akgun 30 Oct '09

30 Oct '09

Hi everybody, I am using the uu-parsinglib to parse a structured language and map the results to some proper data structures. Thanks to Prof Doaitse Swierstra (and other authors if any), it is fun to write a parser using this library. I've been sending private mails to Doaitse about my questions, who kindly gives nice replies everytime. But this time I thought I can ask my question to the community, and give everyone the chance to benefit from the answers. [After the intro, here comes my real question] I am trying to capture the following pattern. pKeyword_Int = ( \ _ _ _ -> "int" ) <$> pSym 'i' <*> pSym 'n' <*> pSym 't' pKeyword_Float = ( \ _ _ _ _ _ -> "float" ) <$> pSym 'f' <*> pSym 'l' <*> pSym 'o' <*> pSym 'a' <*> pSym 't' As you can see there is an obvious pattern if you try to capture a "keyword". If there were a function called pKeyword taking a string as an argument and producing the necessary parser, things would be easier. What I mean is, pKeyword_Int = pKeyword "int" pKeyword_Float = pKeyword "float" I tried to create this pKeyword function myself but I couldn't manage to do it. I can feel that, one can simply add a "<* pReturn []" to the ends of every parser and write a recursion with this base condition. Any suggestions? PS: Actually I'm a little bit uncomfortable since there may be such a function in the library already :) -- Ozgur Akgun

2 1

\Statically checked binomail heaps?
by Maciej Kotowicz 30 Oct '09

30 Oct '09

Hi, first of all this post is literate haskell I'm trying to implement a binomial heaps from okaski's book [1] but as most it's possible to be statically checked for correctness of definition. Remark that binomial heap is list of binomial trees in increasing order of rank and binomial heap of rank r is a node with r child t_1..t_r, where each t_i is binomial tree of rank r - i First I need some langue extension > {-# LANGUAGE TypeFamilies #-} > {-# LANGUAGE EmptyDataDecls #-} > {-# LANGUAGE GADTs #-} > {-# LANGUAGE KindSignatures #-} > {-# LANGUAGE ScopedTypeVariables #-} > module BinTree where second type-level Nats and Bools, and Void i some kind of Top for Nats > data Z > data S a > data Void > data True > data False Ok, let define some nice types ;) OrdLList is list of decreasing collections parametrised by type of element and length with is also highest rank of elements plus one, they are heterogeneous by they ranks > type Forest = OrdLList BinTree > data OrdLList (t :: * -> * -> * ) a :: * -> * where > LNil :: OrdLList t a Z > LCons :: t a n -> OrdLList t a n -> OrdLList t a (S n ) Binomial tree is here, a I know i can't check statically an heap property > data BinTree a :: * -> * where > Node :: Ord a => a -> Forest a n -> BinTree a n Heap is very similar to Forest just reversed order > data OrdGList (t :: * -> * -> * ) a :: * -> * where > GNil :: OrdGList t a Void > GCons :: Lt n m ~ True => t a n -> OrdGList t a m -> OrdGList t a n > type Heap a n = OrdGList BinTree a n Predicate for testing order in Heap > type family Lt a b > type instance Lt Z (S a) = True > type instance Lt (S a) Z = False > type instance Lt (S a) (S b) = Lt a b > type instance Lt a Void = True reflection form type-level nats to Int > class TNum a where > toNum :: a -> Int > instance TNum Z where > toNum _ = 0 > instance TNum a => TNum (S a) where > toNum _ = 1 + toNum (undefined :: a) rank of binomial tree > rank :: TNum n => BinTree a n -> Int > rank t = toNum $ undefined `asTypeOf` (getN t) > getN :: t a n -> n > getN _ = undefined :: n root of binomial trees > root :: BinTree e n -> e > root (Node x _ ) = x And finally first of quite serious function linking two trees with must have the same ranks, giving trees with rank greater by one > link :: Ord a => BinTree a n -> BinTree a n -> BinTree a (S n) > link t1@(Node x c1) t2@(Node y c2) > | x <= y = Node x $ LCons t2 c1 > | otherwise = Node y $ LCons t1 c2 some simple trees for tests > h = GCons t3 $ GCons t GNil > t = link t1 t2 > t1 = Node 3 LNil > t2 = Node 2 LNil > t3 = Node 5 LNil And sadly that's all I can write... for full functionality these data structure should have merge, insert, deleteMin, findMin, defined in [1] as fallow insTree t [] = [t] insTree t ts@(t':ts') | rank t < rank t' = t : ts | otherwise = insTree (link t t') ts' insert x = insTree (Node 0 x []) -- in [1] rank's are write explicit in nodes merge ts [] = ts merge [] ts = ts merge ts1@(t1:ts1') ts2@(t2:ts2') | rank t1 < rank t2 = t1 : merge ts1' ts2 | rank t1 > rank t2 = t2 : merge ts1 ts2' | otherwise = insTree (link t1 t2) $ merge ts1' ts2' removeMinTree [] = error "empty" removeMinTree [t] = (t,[] removeMinTree (t:ts) | root t < root t' = (t,ts) | otherwise = (t',t:ts') where (t',ts') = removeMinTree ts findMin = root . fst . removeMinTree deleteMin ts = merge (rev ts1, ts2) where (Node _ x ts1,ts2) = removeMinTree I try with all this function and with all I have problems with types the types of insTree in my opinion should be sth like: insTree :: (Min n m ~ k,TNum n, TNum m) => BinTree a n -> Heap a m -> Heap a k where Min looks like: type family Min a b type instance Min a Z = Z type instance Min Z a = Z type instance Min (S a) (S b) = S (Min a b) but this won't compile, ghc don't see that k can be the same type as m in first pattern, problems with rest of function was similar exclude removeMinTree with I have no idea what type it should have... Have anyone an idea how make this code working? Any help will be appreciated [1] Purely Functional Data Structures by Chris Okasaki. Cambridge University Press, 1998.

3 2

Upgrading an app from happstack 0.1 to happstack 0.3
by Thomas Hartman 30 Oct '09

30 Oct '09

Upgrading an app from happstack 0.1 to happstack 0.3? Save yourself a few minutes and read this first. http://blog.patch-tag.com/2009/10/30/migrating-from-happstack-0-1-to-happst… -- Need somewhere to put your code? http://patch-tag.com Want to build a webapp? http://happstack.com

1 0

Re: How to fulfill the "code-reuse" destiny of OOP?
by oleg＠okmij.org 30 Oct '09

30 Oct '09

Magicloud Magiclouds wrote > In OOP, when I inherit a class, I also got the members of it. > But in haskell, how to inherit a "data"? Although any OOP system has by definition, objects, not all of them have classes. The best example of a classless (also called 1-level, or prototype-based) OO system is Self, which is still alive. An object is essentially a record of data members. An extended object (an object of an extended class, for a class-based OOP) is an extended record. They could be quite convenient: we can add a new field to an existing record without re-writing the complete declaration and re-using lots of the functions that dealt with the old records. The old code would just work on extended records, ignoring the added field. (I am simplifying a bit.) Lots has been written about extensible records in Haskell; some techniques (such as parameterizing a record type by a tail) have been rediscovered several times. Still a good survey of many various ways to implement extensible records in Haskell is Section 3 of http://homepages.cwi.nl/~ralf/OOHaskell/paper.pdf It is long, as everything else in that paper.

1 0

Re: Finally tagless and ghc-extensions
by oleg＠okmij.org 30 Oct '09

30 Oct '09

> In both, the JFP & APLAS paper, the authors note that no fancy type > extension are needed for this approach. But in almost every (Haskell) > example that is a bit more involved the authors do make use of > functional dependencies and / or type families. GADTs are also being > used, although *not* in the syntax definition... Just to dispel the doubts, here is the Haskell98 version of the previously posted code CB.hs (tagless final interpreter for call-by-name, call-by-value and call-by-need lambda-calculus with integers and constants) http://okmij.org/ftp/Haskell/CB98.hs It may appear somewhat less convenient. How less convenient -- well, you decide. The code can be easily re-written in OCaml, which has no typeclasses, type families and other bleeding edge features. Talking about it here is probably not appropriate. (I wonder if someone has ever cross-posted to the Haskell and Caml lists). P.S. > I'm still digesting the "Finally Tagless" approach from Oleg, Jacques > and Chen. You probably mean Chung-chieh Shan, whose last name is Shan and the first name is Chung-chieh. http://en.wikipedia.org/wiki/Chinese_name

1 0

Singapore Functional Programmer Group First Meetup
by kenny lu 30 Oct '09

30 Oct '09

Sorry for the late notice. We are organizing an informal meeting for the Functional Programmer Group in Singapore on 2 Nov 2009. Since this is the first meeting, the theme will be mainly 'meet and greet' and discuss our interests in functional programming languages. We have participants coming from both the industry and the academia. If you happen to be in Singapore and interested in sharing your experience and interests, please contact Kenny at luzhuomi_AT_gmail_DOT_com. Best Regards, Kenny Zhuo Ming Lu

1 0

wxMac/wxHaskell focus problem, a quick solution
by Iain Barnett 30 Oct '09

30 Oct '09

I was trying to go through some of the wxHaskell examples, and they wouldn't work on my (Tiger) mac. Same thing happened with a few other wx apps I downloaded from Hackage. A bit of a rummage on the internet turned up an issue with wxMac[1]. You need to put the haskell executable in an OSX Application Bundle or you can't get focus on the window. Since I don't know how to use XCode (and quickly got bored of trying to find what I needed to do with it for my needs) I setup an applescript that builds a bare bones app bundle, with a basic plist file too. This is probably something others have gone though and, just in case it might be some use to others, I stuck it here (might be a little bit of overkill using Sourceforge, but I wasn't go to pay for the download space on my blog considering I have zero cash right now). http://sourceforge.net/projects/makebundle/ The applescript has a perl script in it too, so you'll need perl on your machine for it to work. Everything you need to know is in the readme. Iain [1] http://wiki.wxwidgets.org/WxMac_Issues#My_app_can. 27t_be_brought_to_the_front.21

6 10

Marshalling arrays without flakiness?
by Ron de Bruijn 29 Oct '09

29 Oct '09

Hi, I would like to know whether there is a good way to marshal the following structure to C without using pointer arithmetic done by a programmer (as opposed to a tool). typedef struct{ double a[10]; double b[10]; double b[10]; } foo; I don't need this functionality, but it would make Haskell -> C interfaces less flaky. Basically, writing Haskell -> C interfaces seem to be a very unpopular thing to do (as opposed to C -> Haskell interfaces). For example, on Hackage (actually a checkout of a few months ago) there is only one package using pokeArray and it is not pretty; it uses pointer arithmetic and all other kinds of hard-coded addresses. If I change the order of the C fields it will break, if I change the length of the buffer they use, it breaks. Just look at it, and it will break ;) If you are a bit creative, it is possible to make it work already, by using the best features of both hsc2hs and c2hs, but it is hardly elegant. I suppose the real solution would be to extend c2hs with an offsetof function (for which patches already exist, btw), but it might be that I have missed some other solution. -- Best Regards, Ron de Bruijn, Developer, Gamr7

2 2

Command-line options idea
by Robin Green 29 Oct '09

29 Oct '09

This is not in any way specific to Haskell, but I know a number of packages on Hackage have executables with command-line options, so: The non-Haskell program get_iplayer has an excellent idea for command-line options parsing. Rather than having to remember two separate syntaxes, one for command line options and one for a preferences file, the user can simply type get_iplayer --prefs-add --OPTION[=VALUE] which will add the equivalent of --OPTION[=VALUE] to the get_iplayer preferences file (and do nothing else). So it's like a special "preferences file manipulation mode" of the program. There are also the following options, as described by --help: --prefs-clear Remove *ALL* saved user or preset options --prefs-del Remove specified saved user or preset options --prefs-show Show saved user or preset options (This also means that the user doesn't have to remember the filename of the preferences file.) I think this sort of thing would be a good idea for *any* program that has command-line options that some user might want to hold constant across several runs. -- Robin

2 1

frag game - compilation fixes
by Phil Jones 29 Oct '09

29 Oct '09

I've hacked through (senselessly) the various compilation errors (I think they were all related to GLfloat vs. Float, etc.) Frag now compiles and works, but I think I may have introduced some bugs (the weapon doesn't appear on the screen?) Unfortunately, I did the whole job on an unpacked cabal package from hackage, and also I've never used darcs. So here's the resulting package tree (excluding the big files). If anyone knows how to turn it into a darcs working copy and create a patch from it, please do!

3 4

ANNOUNCE: GeBoP 1.7
by Henk-Jan van Tuyl 29 Oct '09

29 Oct '09

L.S., I have updated and cabalized Daan Löffler's GeBoP and uploaded it to Hackage. GeBoP, the General Boardgames Player, offers a set of board games: Ataxx, Bamp, Halma, Hez, Kram, Nim, Reversi, TicTacToe, and Zenix. The application also features a brain viewer which enables you to explore the computer's internal game tree. The homepage is: http://www.haskell.org/haskellwiki/GeBoP Regards, Henk-Jan van Tuyl -- http://functor.bamikanarie.com http://Van.Tuyl.eu/ --

1 0

Finally tagless and ghc-extensions
by Günther Schmidt 29 Oct '09

29 Oct '09

Hi all, ok, I haven't let go on the EDSL subject just yet. I'm still digesting the "Finally Tagless" approach from Oleg, Jacques and Chen. In both, the JFP & APLAS paper, the authors note that no fancy type extension are needed for this approach. But in almost every (Haskell) example that is a bit more involved the authors do make use of functional dependencies and / or type families. GADTs are also being used, although *not* in the syntax definition but merely in the semantic instances, I'm cool with that :) . I haven't touched base yet with either functional dependencies nor type families as I understand the edges on neither are yet worked out, so I'd prefer being able to avoid either when using the tagless approach even in more involved settings. Is that possible? Günther

1 0

cabal probems with binary/containers packages
by brian 29 Oct '09

29 Oct '09

It all started with this: Loading package binary-0.5.0.1 ... can't load .so/.DLL for: HSbinary-0.5.0.1 (dlopen(libHSbinary-0.5.0.1.dylib, 9): image not found) so I tried > cabal upgrade binary Resolving dependencies... Configuring containers-0.2.0.1... Preprocessing library containers-0.2.0.1... Building containers-0.2.0.1... Data/IntMap.hs:182:7: Could not find module `Data.Data': it is a member of package base, which is hidden cabal: Error: some packages failed to install: binary-0.5.0.2 depends on containers-0.2.0.1 which failed to install. containers-0.2.0.1 failed during the building phase. The exception was: exit: ExitFailure 1 help.... Thanks, Brian

2 5

simple parsing
by satorisanitarium 28 Oct '09

28 Oct '09

I'm trying to parse a list of numbers plus four diferent signs (+-*/) in this way: Lets say the list is "32+5/46" result would be "2+5/4" I get: "2+5/4*** Exception: geneticSimple.hs:(55,0)-(65,35): Non-exhaustive patterns in function chromoResult If the list is "32+5**6" result would be "2+5*6" I get: "2+5/*** Exception: geneticSimple.hs:(55,0)-(65,35): Non-exhaustive patterns in function chromoResult If the list is "32+-72" resoult would be "2+7" I get: "2+*** Exception: geneticSimple.hs:(55,0)-(65,35): Non-exhaustive patterns in function chromoResult code: chromoResult [] = [] chromoResult (a:b:c:xs) | elem a "0123456789" && elem b "0123456789" && elem c "0123456789" = chromoResult (c:xs) | elem a "0123456789" && elem b "0123456789" && elem c "+-*/" = b:c: chromoResult xs | elem a "0123456789" && elem b "+-*/" && elem c "0123456789" = a:b:c : chromoResult xs | elem a "0123456789" && elem b "+-*/" && elem c "+-*/" = a:b : chromoResult (c:xs) | elem a "+-*/" && elem b "0123456789" && elem c "0123456789" = chromoResult (b:c:xs) | elem a "+-*/" && elem b "0123456789" && elem c "+-*/" = b:c : chromoResult xs | elem a "+-*/" && elem b "+-*/" && elem c "0123456789" = chromoResult (c:xs) | elem a "+-*/" && elem b "+-*/" && elem c "+-*/" = chromoResult xs | otherwise = chromoResult (b:c:xs) I suspect my approach is flawed but i have exausted my ideas. I need a fresh approach so if anybody would be kind enough and just give me a hint how to approach the problem. Thx in advance.

4 3

What *is* a DSL?
by Günther Schmidt 28 Oct '09

28 Oct '09

Hi all, for people that have followed my posts on the DSL subject this question probably will seem strange, especially asking it now. I have read quite a lot lately on the subject, most of it written by the great old ones, (come on guys you know whom I mean :)). What I could gather from their papers was, that a DSL is basically something entirely abstract as such, ie. it allows you build and combine expressions in a language which is specific for your problem domain. Irregardless of further details on how to do that, and there are quite a few, the crux as such is that they are abstract of "meaning". The meaning depends how you *evaluate* the expression, which can be in more than merely one way, which is where, as far as I understand it, the true power lies. So, you might wonder, since I figured it out this far, why ask what a DSL is? Because out there I see quite a lot of stuff that is labeled as DSL, I mean for example packages on hackage, quite useuful ones too, where I don't see the split of assembling an expression tree from evaluating it, to me that seems more like combinator libraries. Thus: What is a DSL? Günther

18 39

cabal haddock hpc, exposed modules?
by Greg Fitzgerald 28 Oct '09

28 Oct '09

I have a cabal package that defines a few dozen modules, and I'm hoping to generate documentation and code coverage for all modules without listing each module explicitly. currently my .cabal includes: library exposed-modules: Language.Idl.Data, Language.Idl.Merge, Language.Idl.Parser, ...lots more... my Setup.hs includes an explicit system call to hpc: exec "hpc" ["markup" , "--include=Language.Idl.Data" , "--include=Language.Idl.Merge" , "--include=Language.Idl.Parser" ...all the same files as above... ] Questions: 1) Is there a way to create haddock docs for /all/ modules, instead of just the ones listed by 'exposed-modules'? 2) Is there a way to query cabal for the list of modules? Or by chance has hpc recently been integrated with cabal? Thanks, Greg

2 4

Re: uu-parsinglib pKeyword
by S. Doaitse Swierstra 28 Oct '09

28 Oct '09

pToken [] = pSucceed [] pToken (x:xs) = (:) <$> pSym x <*> pToken xs pKeyword_Float = pToken "Float" etc Doaitse PS: this function has been defined in the module Text.ParserCombinators.UU.Derived On 28 okt 2009, at 17:39, Ozgur wrote: > Hi everybody, > > I am using the uu-parsinglib to parse a structured language and map > the results to some proper data structures. Thanks to Prof Doaitse > Swierstra (and other authors if any), it is fun to write a parser > using this library. > > I've been sending private mails to Doaitse about my questions, who > kindly gives nice replies everytime. But this time I thought I can ask > my question to the community, and give everyone the chance to benefit > from the answers. > > [After the intro, here comes my real question] > > I am trying to capture the following pattern. > > pKeyword_Int = ( \ _ _ _ -> "int" ) <$> pSym 'i' <*> pSym 'n' <*> pSym > 't' > pKeyword_Float = ( \ _ _ _ _ _ -> "float" ) <$> pSym 'f' <*> pSym 'l' > <*> pSym 'o' <*> pSym 'a' <*> pSym 't' > > As you can see there is an obvious pattern if you try to capture a > "keyword". If there were a function called pKeyword taking a string as > an argument and producing the necessary parser, things would be > easier. > > What I mean is, > > pKeyword_Int = pKeyword "int" > pKeyword_Float = pKeyword "float" > > I tried to create this pKeyword function myself but I couldn't manage > to do it. > > I can feel that, one can simply add a "<* pReturn []" to the ends of > every parser and write a recursion with this base condition. > > Any suggestions? > > PS: Actually I'm a little bit uncomfortable since there may be such a > function in the library already :)

4 4

Cabal says "no installed version of base"
by John Velman 28 Oct '09

28 Oct '09

I'm on OS X Leopard 10.5.8, using ghc 6.10.4 from Haskell Platform. I'm trying to get a static .a library, callable from C, that I can use in an OS X Cocoa program. I've tried a very simple case (the one in Haskell Wiki Tutorials,"calling haskell from C") I've managed to make a Mac Cocoa application by adding the ghc generated .o program, plus adding one by one the needed Haskell libraries for "symbol not found" to my Xcode project. There should be a better way. I've tried just about everything I could find on creating Haskell libraries, with no joy. My latest try is to use Cabal, following advice found both in "How to write a Haskell program" and the Cabal users guide. My output from cabal -v configure tells me, among others: --- Reading installed packages... /usr/bin/ghc-pkg dump --global /usr/bin/ghc-pkg dump --user Reading available packages... Resolving dependencies... There is no installed version of base --- But when I do ghc-pkg dump --global it appears base is listed. Apparently, "no installed version of base" short circuits the whole process. Any suggestions, pointers to reading, whatever will be appreciated.

2 2

Fwd: [Haskell-cafe] Market Place for Haskell development teams?
by Alberto G. Corona 28 Oct '09

28 Oct '09

forwarded to the list: Curt, Rubi and Pyton came into existencie without their internet libraries, but they would´nt be popular without them. Although I conffess I don´t know the history in detail. Academics is not mainstream. 2009/9/29 Curt Sampson <cjs(a)starling-software.com> > On 2009-09-29 13:18 +0200 (Tue), Alberto G. Corona wrote: > > > Java is part of the Java platform, that brought OS independence and > > interoperability at the right time. .Download-execution on the client > > was also a reason for the initial success of Java in the Internet era. > > I was a die-hard Java hacker from 1999 until some undetermined time in > the early-to-mid-2000s. (I abandoned it more or less completely sometime > around late 2005, if I recall correctly.) > > This may be somewhat anecdotal evidence, but I disagree with both > of your statements here. > Of course, I´m not talking about real advantages of Java or any PL. I told about the reasons that people used at the time to introduce the language in the mainstream, either is desirable this for haskell or not. I think it is. Nobody consider the runtime download of Java code important nowadays. Not even the cross-platform features. but it was marketeed at his time as such. > > Rubi and Python came with libraries targeted to Rapid development of > > Internet applications. > > No, neither originally "came" with that. > Rubi and Pyton came into existencie without their internet libraries, but they would´nt be popular without them. Although I conffess I don´t know the history in detail. > > What is the vehicle that haskell can use to enter the mainstream?. > > That may be the wrong question. "Avoid success at all costs" still > rings true to me. A year or so ago I seemed like one of the few on > the haskell-libraries list voting in favour of fixing API problems in > libraries, rather than etching in stone those problems in the name of > backwards compatibility so that we could "become more popular." > > Said above. We have different goals. > Do you really want, in 2020, to look back at the 2010 revision of the > Haskell standard and think, "we entrenched things that for a decade > everybody agreed was dumb"? > I see no problem in haskell having both. experimental and fixed versions. Haskell 2020 for you and me and haskell 2010 for my commercial code. Both woukd ve maintained and enriched by far more people. > > I can tell you, even when you're a Java enthusiast, there's nothing > more depressing than looking at java.util.Date and thinking, "That > should have been immutable, but it's going to be mutable for the rest of > eternity. We will never fix that." > > But let's try this again: > > > What is the vehicle that haskell can use to enter the mainstream?. > > Become more stupid. > > Is that a better answer? I'm not just a geek; I do marketing too (this > is what happens when you start your own company), and if you asked me, > using the utmost of my technical knowledge and marketing skills, to make > Haskell popular, this is what I'd recommend. > > Become more stupid may mean "give exactly what the people want" that transaltes to be more stable, give libraries, platforms etc. That is not a extra effor. that will come naturally as more people use the language. some people is naturally more abstract. some are more practical. > (I suppose it's a sign of my professionalism that to do this would > nearly break my heart, but if you wanted me to tell you the best way to > do this, and I couldn't tell you to get lost, that's what I'd say.) > > > Many people will play with Haskell in the spare time, and many of them > > will be permitted to develop some non critical applications at work. > > But that is all. > > Hm. So I suppose that this options trading system I'm working on, which > is the sole way our business makes money and is entirely written in > Haskell, doesn't actually exist. > > Congratulations.!! > > I think that all the current niches are filled, but new niches are > coming. > > Haskell already has a good niche. In fact, a brilliant one. We have > a whole bunch of academics doing truly wonderful stuff (imagine the > world without monads!--thank you Philip Wadler (and Eugenio Moggi)) > that the rest of us (relatively) dumb idiots can use to make our lives > better. We've got several very good implementations of the language, > one of which is a truly shit-hot compiler[1]. And we can use that to do > commercial applications quite comfortably[2]. > > Right. ;) > My personal opinion is, yes, let's let Haskell stick to the niche where > it's great, but it changes so fast that it's scary to everybody else. To > echo Paul Graham, I'm extremely happy to see my competition use Java. > > [1] Like that's so important. Ruby's standard implementation to this day > is an interpreter that implements all the popular extensions and has a > reasonably decent FFI. In Haskell-land, we call that "Hugs." It's only > because we have GHC as well that we can look down on Hugs; in the Ruby > (and Python, and PHP) worlds, they're saying that interpreters are just > fine for all sorts of "enterprise applications." > > [2] (Warning: self-promotion): > http://www.starling-software.com/misc/icfp-2009-cjs.pdf > > > Financial applications are an example of higher level programming > > where tasks usually performed by humans are now automatized and there > > is no or few traditions about that. The need to think at a higher > > level without being worried by side effects and other details are > > specially needed in such kind of areas. That's where haskell could > > have its own niche. > > Actually, I think that Haskell has a niche there not because of that > sort of thing, but merely because it's better than Java at doing what > Java does well, but scary enough that only small groups of brave > people who are comfortable with risk would ever attempt to use it. The > financial sector happens to have a lot more of those than many others. > > same concept in more plain words. I guess. > cjs > -- > Curt Sampson <cjs(a)starling-software.com> +81 90 7737 2974 > Functional programming in all senses of the word: > http://www.starling-software.com >

14 29