March 2010 - Haskell-Cafe

openFile and portability
by Ketil Malde 23 Mar '10

23 Mar '10

Hi, For convenience, I often build binaries with -optl-static, and distribute them. Except for the slightly annoying necessity of adding -optl-pthread as well, this works great. Now I just upgraded my Ubuntu box from 9.10 (Karmic) to 10.4 (Lucid), and suddently static binaries refuse to work on other machines, specifically I get: openFile: invalid argument (Invalid argument) This seems to happen for any program trying to read a file, for instance: main = readFile "/etc/passwd" >>= putStrLn The program will compile and work as expected, but fails if I move it to a computer with an older distribution (I've tested RHEL and CentOS 5.4 so far). I tried strace, and the call to open appears to be similar, and succeed in all cases. Any ideas? -k -- If I haven't seen further, it is by standing in the footprints of giants

1 0

Graphical representation of Haskell code
by Dupont Corentin 23 Mar '10

23 Mar '10

Hello, I’m relatively new to Haskell. I’m wondering if it exist a tool to graphically represent Haskell code. Look at the little graphics at: http://www.haskell.org/arrows/index.html (and following pages) from Ross Paterson. <http://www.haskell.org/arrows/index.htm> If found these very useful to understand the Arrow monad. Why not automatise this in a tool? Such a tool could draw a graphic from the code of a program. This could be done entirely automatically from the types of the functions. Let’s try to do it on a simple example, as an exercise: f = Map (+1) How does this function could be represented? It contains the (+) function. This function has the type (+) :: Num a => a -> a -> a. >From this type we could deduce the graphic: [image: Haskell schematic_html_m20060f13.gif] Or a curried version: [image: Haskell schematic_html_5155f0eb.gif] The function (+1) then is: [image: Haskell schematic_html_m68795eb7.gif] The function map could be drawn like this : [image: Haskell schematic_html_m28c92a58.gif] Or like this: [image: Haskell schematic_html_m6ae433ea.gif] And the entire function map (+1) could be represented as: [image: Haskell schematic_html_macb1643.gif] Thanks to the advanced type system of Haskell, everything could be deduced from the type signatures. Such a tool would be recreational and educational. One could zoom in and out in a program, to display more or less details. This could help understand a program, globally or locally. We could even imagine a constructive version of the tool, where the programmer would draw functions from a toolbox, and stick them into the graphic! Does a tool approaching this already exist? If not, would it be a good project? Cheers, Corentin

6 5

Hackape package lackage
by Dougal Stanton 23 Mar '10

23 Mar '10

Hackage seems to be down again. $ cabal update Downloading package list from server 'http://hackage.haskell.org/packages/archive' ^Ccabal: interrupted $ ping -c3 hackage.haskell.org PING abbot.galois.com (69.30.63.204) 56(84) bytes of data. --- abbot.galois.com ping statistics --- 3 packets transmitted, 0 received, 100% packet loss, time 2012ms

4 3

ICFP 2010: Final Call for Papers
by Wouter Swierstra 23 Mar '10

23 Mar '10

===================================================================== Final Call for Papers ICFP 2010: International Conference on Functional Programming Baltimore, Maryland, 27 -- 29 September 2010 http://www.icfpconference.org/icfp2010 ===================================================================== Important Info ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Submission: 2 April 2010 Author response: 24 -- 25 May 2010 Notification: 7 June 2010 Final papers due: 12 July 2010 All deadlines are at 14:00 UTC. Submission is now open at http://icfp2010.seas.upenn.edu/ Scope ~~~~~ ICFP 2010 seeks original papers on the art and science of functional programming. Submissions are invited on all topics from principles to practice, from foundations to features, from abstraction to application. The scope includes all languages that encourage functional programming, including both purely applicative and imperative languages, as well as languages with objects or concurrency. Particular topics of interest include * Language Design: type systems; concurrency and distribution; modules; components and composition; metaprogramming; relations to object-oriented or logic programming; interoperability * Implementation: abstract machines; compilation; compile-time and run-time optimization; memory management; multi-threading; exploiting parallel hardware; interfaces to foreign functions, services, components or low-level machine resources * Software-Development Techniques: algorithms and data structures; design patterns; specification; verification; validation; proof assistants; debugging; testing; tracing; profiling * Foundations: formal semantics; lambda calculus; rewriting; type theory; monads; continuations; control; state; effects * Transformation and Analysis: abstract interpretation; partial evaluation; program transformation; program calculation; program proof * Applications and Domain-Specific Languages: symbolic computing; formal-methods tools; artificial intelligence; systems programming; distributed-systems and web programming; hardware design; databases; XML processing; scientific and numerical computing; graphical user interfaces; multimedia programming; scripting; system administration; security; education * Functional Pearls: elegant, instructive, and fun essays on functional programming The conference also solicits Experience Reports, which are short papers that provide evidence that functional programming really works or describe obstacles that have kept it from working in a particular application. Abbreviated instructions for authors ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ By 2 April 2010, 14:00 UTC, submit an abstract of at most 300 words and a full paper of at most 12 pages (6 pages for an Experience Report), including bibliography and figures. The deadline will be strictly enforced and papers exceeding the page limits will be summarily rejected. Authors have the option to attach supplementary material to a submission, on the understanding that reviewers may choose not to look at it. A submission will be evaluated according to its relevance, correctness, significance, originality, and clarity. It should explain its contributions in both general and technical terms, clearly identifying what has been accomplished, explaining why it is significant, and comparing it with previous work. The technical content should be accessible to a broad audience. Functional Pearls and Experience Reports are separate categories of papers that need not report original research results and must be marked as such at the time of submission. Detailed guidelines on both categories are on the conference web site. Each submission must adhere to SIGPLAN's republication policy, as explained on the web at http://www.acm.org/sigplan/republicationpolicy.htm. Proceedings will be published by ACM Press. Authors of accepted submissions are expected to transfer the copyright to the ACM. Presentations will be videotaped and released online if the presenter consents by signing an additional permission form at the time of the presentation. Formatting: Submissions must be in PDF format printable in black and white on US Letter sized paper and interpretable by Ghostscript. If this requirement is a hardship, make contact with the program chair at least one week before the deadline. Papers must adhere to the standard ACM conference format: two columns, nine-point font on a ten-point baseline, with columns 20pc (3.33in) wide and 54pc (9in) tall, with a column gutter of 2pc (0.33in). A suitable document template for LATEX is available from SIGPLAN at http://www.acm.org/sigs/sigplan/authorInformation.htm. Submission: Submissions will be accepted electronically at a URL to be named later. Improved versions of a paper may be submitted at any point before the submission deadline using the same web interface. Author response: Authors will have a 48-hour period, starting at 14:00 UTC on 24 May 2010, to read and respond to reviews. Special Journal Issue: There will be a special issue of the Journal of Functional Programming with papers from ICFP 2010. The program committee will invite the authors of select accepted papers to submit a journal version to this issue. Organization ~~~~~~~~~~~~ Conference Chair Paul Hudak, Yale University Program Chair Stephanie Weirich, University of Pennsylvania Program Committee: Umut Acar, Max Planck Institute for Software Systems Zena Ariola, University of Oregon James Cheney, University of Edinburgh Peter Dybjer, Chalmers University of Technology Robert Bruce Findler, Northwestern University Andy Gill, Kansas University Fritz Henglein, University of Copenhagen Michael Hicks, University of Maryland, College Park Patricia Johann, University of Strathclyde Andres Löh, Utrecht University Simon L. Peyton Jones, Microsoft Research Didier Rémy, INRIA Paris-Rocquencourt John Reppy, University of Chicago Manuel Serrano, INRIA Sophia-Antipolis Matthieu Sozeau, Harvard University

1 0

CUFP mailing list
by Günther Schmidt 22 Mar '10

22 Mar '10

Hi everyone, is there a mailing list for CUFP-lers? I have some questions that are related to commercial software development (in Haskell) which I don't think fit well on this list. Günther

4 7

Zarathustra
by Günther Schmidt 22 Mar '10

22 Mar '10

Hi Cliff, here is a link which might interest you http://en.wikipedia.org/wiki/Zoroastrianism Love Günther

1 0

Strange typing?
by Ozgur Akgun 22 Mar '10

22 Mar '10

Hi Cafe! Disclaimer: I know what I'm going to ask is now available as a language feature normally. And sorry for the subject of this message, I couldn't compe up with a good&descriptive subject. Is there any way to limit a functions type, not by a data type but by a group of constructors of a data type? If not, what would be the *right* thing to do to achieve this level of type safety? data DT1 = X | Y | Z data DT2 = A | B | C | D func1 :: DT1 -> DT2 -- instead of this func1' :: (X|Y) -> (B|C) -- i want sth. like this. (| means or) Only think I can think of is having the constructors, as seperate data types, introducing new type classes to group every possible subset of [X,Y,Z] and [A,B,C,D] and use those type classes when defining the functions. But as you can imagine, this is not the only place I want to use this thing, and the code will start to look cryptic if I do so. I must add, I want to use this *disjunction of constructors* thingy in data type declerations as well. A little bit brainstorming maybe? Thanks in advance, -- Ozgur Akgun

6 7

RFC: only-read-or-write-vars
by Bas van Dijk 22 Mar '10

22 Mar '10

Hello, I've written a tiny package for restricting access to mutable variables to be read-only or write-only: http://code.haskell.org/~basvandijk/code/only-read-or-write-vars/ This is a Request For Comments, so any comments / patches / +1s / -1s about anything are more than welcome before I upload it to hackage (sometime this weekend). regards, Bas

2 3

ANN: Three package announcements
by Mario Blažević 22 Mar '10

22 Mar '10

There are three new packages on Hackage: - monad-parallel 0.5 (http://hackage.haskell.org/package/monad-parallel) - monad-coroutine 0.5 (http://hackage.haskell.org/package/monad-coroutine) - Streaming Component Combinators 0.5 (http://hackage.haskell.org/package/scc) The first two packages are completely new. Their functionality has been present in SCC 0.4, but I thought they might be useful on their own. I'm keeping all the version numbers in sync for now, and the source code for all three packages is in a single Darcs repository at http://code.haskell.org/SCC/. The monad-parallel library defines two Monad subclasses, MonadParallel and MonadFork, that enable monadic computations to be executed in parallel and their results combined. The library also exports a subset of the Control.Monad interface (ap, sequence, and related functions), adjusted to exploit the parallelism. The only currently defined MonadParallel instances are IO, Maybe, [], and Identity. More instances could be added, but I didn't want the package to depend on MTL or transformers. The library design was heavily influenced by the discussion in this Cafe thread: http://www.mail-archive.com/haskell-cafe@haskell.org/msg68581.html The monad-coroutine package exports a generic monad transformer Coroutine: Functor s => MonadTrans (Coroutine s). A Coroutine-transformed monad can suspend at any point, returning its resumption wrapped in the functor s. There are also some functions for manipulating and running coroutines, as well as a couple of useful suspension functors such as Yield and Await. Finally, version 0.5 of Streaming Component Combinators (a.k.a. SCC) comes with some significant code refactoring (as the two aforementioned packages prove), simplifications, and performance enhancements. No new features have been added since the 0.4 release.

1 0

ANNOUNCE: AusHac2010
by Ivan Lazar Miljenovic 22 Mar '10

22 Mar '10

Dreading the end of ZuriHac? Wish the Haskellian camaraderie could continue? Well, if you're able to make your way to Sydney, Australia between the 16th and 18th of July, then AusHac2010 is for _you_! It will be held at the School of Computer Science and Engineering at the University of New South Wales (thanks to Manuel Chakravarty and Ben Lippmeier for offering to organise the rooms!). If you are wanting to attend the inaugural Australian Hackathon, please register at http://axman6.wufoo.com/forms/aushac-2010-sign-up/ . For more information, see http://www.haskell.org/haskellwiki/AusHac2010 We will shortly be adding an extended version of the "Who" table; please also add your details there as well as which projects you would be interested in hacking in. Hoping to see you there! -- Ivan Lazar Miljenovic Ivan.Miljenovic(a)gmail.com IvanMiljenovic.wordpress.com

1 0