- Haskell-Cafe - Haskell.org

ANNOUNCE: haskell-packages-0.1
by Roman Cheplyaka 27 May '13

27 May '13

I am happy to announce the first release of haskell-packages. http://haskell-suite.github.io/haskell-packages/ There are two cases when you may need haskell-packages: if you are writing a Haskell compiler (or any tool that processes Haskell source code, such as a static analyzer), or if you want to integrate with an existing Haskell compiler that uses haskell-packages. ## Writing a compiler If you are writing a compiler, you typically want to integrate it with Cabal, to be able to build ordinary Haskell packages. If you go the hard way, this involves: 1. **Parsing command line parameters**. Sounds easy — just take a list of files to compile. In reality you also need to handle package ids and package dbs, CPP options (`-DFOO=1`), language extension flags (`-XRankNTypes`) etc. To integrate with Cabal, you also need to tell it the list of installed packages, supported languages and extensions etc. 2. Actual **integration with Cabal** means understanding how Cabal works and hard-coding support for your compiler. And then getting it accepted and waiting for the next Cabal release. You may pretend that you are GHC or other compiler that is already supported by Cabal. It might work, but often it won't, for various reasons. Also, GHC's command line protocol is quite complex. 3. **Package management**. You need to implement a package db mechanism, which would let you to keep track of installed packages. Then you'd have to implement a `ghc-pkg`-like tool to manage those databases, for both Cabal and your users. **Or**, you can simply use this library! It already has command line options parsing, Cabal support, and package management. All you need to do is to provide the function to do actual compilation and tell a couple of other things about your compiler. See the `Distribution.HaskellSuite.Compiler` module for details. ## Using other compilers Some compilers produce artifacts that you may want to use. A good example is the `gen-iface` compiler from haskell-names which generates an *interface* for each module — the set of all named entities (functions, types, classes) that are exported by that module. This information can be then used either by other compilers, or by tools like IDEs. Assuming the compiler uses haskell-packages and exports its database type, it's very easy to use its artifacts. See `Distribution.HaskellSuite.Packages` for package resolution and `Distribution.HaskellSuite.Modules` for module resolution. ## Installation Note that haskell-packages uses (yet unreleased) haskell-src-exts 1.14. Get it [here][hse]. It doesn't matter what Cabal version you use together with haskell-packages, but if you want to invoke a haskell-packages compiler from Cabal (see [Usage](#usage)), you need to build our [fork of Cabal][Cabal]. Eventually it will be merged into Cabal. [hse]: https://github.com/haskell-suite/haskell-src-exts [Cabal]: https://github.com/feuerbach/Cabal ## Usage To compile a Haskell package using a haskell-packages tool: cabal install --haskell-suite -w $TOOL where `$TOOL` may be either a full path to the compiler, or just an executable name if it's in `$PATH`.

1 0

Call for Papers IFL 2013
by publicityifl＠gmail.com 27 May '13

27 May '13

Hello, Please, find below the first call for papers for IFL 2013. Please forward these to anyone you think may be interested. Apologies for any duplicates you may receive. best regards, Jurriaan Hage Publicity Chair of IFL CALL FOR PAPERS 25th SYMPOSIUM ON IMPLEMENTATION AND APPLICATION OF FUNCTIONAL LANGUAGES - IFL 2013 RADBOUD UNIVERSITY NIJMEGEN, THE NETHERLANDS ACM In-Cooperation / ACM SIGPLAN AUGUST 28 - 30 2013 "Landgoed Holthurnsche Hof" http://ifl2013.cs.ru.nl We are proud to announce that the 25th edition of the IFL series returns to its roots at the Radboud University Nijmegen in the Netherlands. The symposium is held from 28th to 30th of August 2013. Scope ----- The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2013 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Following the IFL tradition, IFL 2013 will use a post-symposium review process to produce the formal proceedings which will be published in the ACM Digital Library. All participants of IFL 2013 are invited to submit either a draft paper or an extended abstract describing work to be presented at the symposium. At no time may work submitted to IFL be simultaneously submitted to other venues; submissions must adhere to ACM SIGPLAN's republication policy: http://www.sigplan.org/Resources/Policies/Republication The submissions will be screened by the program committee chair to make sure they are within the scope of IFL, and will appear in the draft proceedings distributed at the symposium. Submissions appearing in the draft proceedings are not peer-reviewed publications. Hence, publications that appear only in the draft proceedings do not count as publication for the ACM SIGPLAN republication policy. After the symposium, authors will be given the opportunity to incorporate the feedback from discussions at the symposium and will be invited to submit a revised full article for the formal review process. From the revised submissions, the program committee will select papers for the formal proceedings considering their correctness, novelty, originality, relevance, significance, and clarity. Invited Speaker --------------- Lennart Augustsson, currently employed by the Standard Chartered Bank, well-known for his work on Haskell, parallel Haskell, Cayenne, and Bluespec, is the invited speaker of IFL 2013. He will be talking about practical applications of functional programming. Submission Details ------------------ Submission deadline draft papers: July 31 Notification of acceptance for presentation: August 2 Early registration deadline: August 7 Late registration deadline: August 14 Submission deadline for pre-symposium proceedings: August 21 25th IFL Symposium: August 28-30 Submission deadline for post-symposium proceedings: November 11 Notification of acceptance for post-symposium proceedings: December 18 Camera-ready version for post-symposium proceedings: February 3 2014 Prospective authors are encouraged to submit papers or extended abstracts to be published in the draft proceedings and to present them at the symposium. All contributions must be written in English. Papers must adhere to the standard ACM two columns conference format. For the pre-symposium proceedings we adopt a 'weak' page limit of 12 pages. For the post-symposium proceedings the page limit of 12 pages is firm. A suitable document template for LaTeX can be found at: http://www.acm.org/sigs/sigplan/authorInformation.htm Papers are to be submitted via the conference's EasyChair submission page: https://www.easychair.org/conferences/?conf=ifl2013 Topics ------ IFL welcomes submissions describing practical and theoretical work as well as submissions describing applications and tools in the context of functional programming. If you are not sure whether your work is appropriate for IFL 2013, please contact the PC chair at rinus(a)cs.ru.nl. Topics of interest include, but are not limited to: language concepts type systems, type checking, type inferencing compilation techniques staged compilation run-time function specialization run-time code generation partial evaluation (abstract) interpretation metaprogramming generic programming automatic program generation array processing concurrent/parallel programming concurrent/parallel program execution embedded systems web applications (embedded) domain specific languages security novel memory management techniques run-time profiling performance measurements debugging and tracing virtual/abstract machine architectures validation, verification of functional programs tools and programming techniques (industrial) applications Peter Landin Prize ------------------ The Peter Landin Prize is awarded to the best paper presented at the symposium every year. The honoured article is selected by the program committee based on the submissions received for the formal review process. The prize carries a cash award equivalent to 150 Euros. Programme committee ------------------- Thomas Arts, Quviq, Gothenburg, Sweden Andrew Butterfield, Trinity College, Dublin, Ireland Edwin Brady, University of St. Andrews, UK Clemens Grelck, University of Amsterdam, Netherlands Adam Granicz, IntelliFactory, Budapest, Hungary Jeremy Gibbons, University of Oxford, UK Fritz Henglein, University of Copenhagen, Denmark Stephan Herhut, Intel Labs, Santa Clara, US Ralf Hinze (co-chair), University of Oxford, UK Zoltán Horváth, Eötvös Loránd University, Budapest, Hungary Zhenjiang Hu, University of Tokyo, Japan Mauro Jaskelioff, Universidad Nacional de Rosario, Argentina Johan Jeuring, University of Utrecht, Netherlands Rita Loogen, University of Marburg, Germany Marco T. Morazán, Seton Hall University, New Jersey, US Dominic Orchard, University of Cambridge, UK Rinus Plasmeijer (chair), Radboud University Nijmegen, Netherlands Tim Sheard, Portland State University, US Sam Tobin-Hochstadt, Northeastern University / Indiana University, US Peter Thiemann, University of Freiburg, Germany Simon Thompson, University of Kent, UK Venue ----- The 25th IFL is organized by the Radboud University Nijmegen, Model Based Software Development Department at the Nijmegen Institute for Computing and Information Sciences. The event is held in the Landgoed Holthurnsche Hof, a rural estate in the woodlands surrounding Nijmegen. It can be reached quickly and easily by public transport.

1 0

GADT and instance deriving
by TP 27 May '13

27 May '13

Hello, I continue my learning of "not so obvious" Haskell/GHC topics when encountering problems in the code I write. Below is a small example of an heterogeneous list, using GADT, inspired from: http://en.wikibooks.org/wiki/Haskell/Existentially_quantified_types#Example… ---------- {-# LANGUAGE GADTs #-} data Box where Box :: Eq s => s -> Box instance Eq Box where (Box s1) == (Box s2) = s1 == s2 ---------- This code does not compile, because GHC is not sure that s1 and s2 have the same type: ---------- Could not deduce (s ~ s1) from the context (Eq s) bound by a pattern with constructor Box :: forall s. Eq s => s -> Box, in an equation for `==' at test_eq_GADT_before.hs:8:6-11 [and more lines...] ---------- (Do you confirm that tilde in s~s1 means "s has the same type as s1"? I have not found this information explicitly in the Haskell stuff I have read). I have googled on the topic, and found: http://stackoverflow.com/questions/6028424/defining-eq-instance-for-haskell… >From the proposed solution, I wrote: ---------- {-# LANGUAGE GADTs #-} {-# LANGUAGE DeriveDataTypeable #-} import Data.Typeable data Box where Box :: (Typeable s, Eq s) => s -> Box deriving Typeable instance Eq Box where (Box s1) == (Box s2) = Just s1 == cast s2 ---------- that seems to work correctly: ---------- let a = Box (2::Int) let b = Box (2::Float) print $ a == b print $ a == a ---------- Is this the right way to go? Is there any other solution? Thanks, TP

5 12

ANNOUNCE: new bridge! (prelude-prime)
by Roman Cheplyaka 27 May '13

27 May '13

I liked Andreas's idea (cited below). Hence the new package prelude-prime. https://github.com/feuerbach/prelude-prime http://hackage.haskell.org/package/prelude-prime Pull requests are welcome, but let's stick to widely agreed changes (like the Foldable/Traversable one). I think one of the reasons why other Preludes haven't been adopted is because they were too radical. Let's see whether people here can put their code where their mouth is :) Roman * Andreas Abel <andreas.abel(a)ifi.lmu.de> [2013-05-20 13:26:05+0200] > Maybe instead of fiddling with the current Prelude (which might break > backwards compatibility), we should design a new prelude which is not > automatically loaded but contains roughly the current prelude (with > the list functions generalized to collections) plus the "modern" type > class stack: Functor, Applicative, Monad, Foldable, Traversable, > Monoid etc. > > I am willing to write > > {-# LANGUAGE NoImplicitPrelude #-} > import Base > > if I get a decent, "modern" standard set of functions that could be > considered as the base vocabulary of modern Haskell programmers... > > I just do not want to think about the democratic process involved in > this design... > > Cheers, > Andreas

7 9

Fwd: Cabal config file Guide
by Daniel Díaz Casanueva 26 May '13

26 May '13

Thank you, Albert, what you wrote is very useful. Why the Cabal Guide is lacking this kind of information? Maybe I should start gathering information in one place myself! Thank you, Daniel Díaz.

1 0

Cabal config file Guide
by Daniel Díaz Casanueva 26 May '13

26 May '13

Hello Cafe! As you already know, cabal-install is configured in the file "config". It has a lot of fields, but I didn't find a single place where each field is explained with detail. Most of the options are trivial enough to understand what they do without previous explanation, but some of them aren't. Therefore, in order to know what these options do, you have to search info about that one specifically, when it would be much more convenient to have all the information together. So, is there any place like this out there in the web? Thank you, Daniel Díaz.

2 1

ghc release schedule
by Rustom Mody 26 May '13

26 May '13

I give "ghc release schedule" to google and get at/near the top: http://hackage.haskell.org/trac/ghc/wiki/Status/Releases whose title is "Release plans for ghc 6.12"

1 0

Debugging embedded ruby interpreter
by Simon Marechal 24 May '13

24 May '13

Hello, I am trying to embed a ruby interpreter into my Haskell library. It didn't seem complicated, and went flawlessly until I tried using it a lot. Then I got segfaults. Here is a test program that corrupts the Array object that is being created : https://github.com/bartavelle/hruby/blob/271d99e26a5df075b1011e4b30adf6addd… Changing line 46 to this makes it work: v <- pick (listOf arbitrary :: Gen [Double]) And this version makes it fail again : v <- pick (listOf subvalue :: Gen [Value]) As you can see, the "frequencies" of "subvalue" are set so that only JSON Values representing Doubles are generated. As the toRuby and fromRuby instances for Value are just pure wrappers over the instances for Double, the non-pure code that is executed should be the same. Am I wrong here ? Given that there is almost no documentation for doing this Ruby embedding, I am unsure that I am doing it right. I looked at the Hubris code and several other sources on the Internet, but can't find what is wrong with my implementation. I have no clue on how to debug this. Valgrind gives me a few "Conditional jump or move depends on uninitialised value(s)" during Ruby's gc, but I get more or less the same when just running the native interpreter. Also running this with the multithreaded runtime makes it fail immediately. Anyone has an idea on how I should approach this problem ?

1 1

How not to force ghci debugger but still know the _result?
by haskell-cafe＠maartenfaddegon.nl 23 May '13

23 May '13

Hi, As the subject says, I'd like to use the GHCI debugger to inspect the results of some functions. I tried to set ":break"-points on these functions and ":step" through them, but unless I use ":force" I never get to see the result of these functions. Is it possible to somehow break when the result is evaluated? Please find below a log of my attempts to debug a small example, where during debugging none of the "_result" values is ever known/shown. Maarten Faddegon -- $ cat bla1.hs blabla :: [Int] -> Int bla :: Int -> Int papperlap :: Int -> Int -> Int bla x = x+x papperlap y x = ((y *) . bla) x blabla xs = foldl papperlap 0 xs $ ghci bla1.hs GHCi, version 7.6.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. [1 of 1] Compiling Main ( bla1.hs, interpreted ) Ok, modules loaded: Main. *Main> :break blabla Breakpoint 0 activated at bla1.hs:7:1-36 *Main> :break papperlap Breakpoint 1 activated at bla1.hs:6:1-31 *Main> :break bla Breakpoint 2 activated at bla1.hs:5:1-19 *Main> blabla [1,2,3] Stopped at bla1.hs:7:1-36 _result :: Int = _ [bla1.hs:7:1-36] *Main> :step Stopped at bla1.hs:7:17-36 _result :: Int = _ xs :: [Int] = [1,2,3] [bla1.hs:7:17-36] *Main> :step Stopped at bla1.hs:6:1-31 _result :: Int = _ [bla1.hs:6:1-31] *Main> :step Stopped at bla1.hs:6:17-31 _result :: Int = _ x :: Int = 3 y :: Int = _ [bla1.hs:6:17-31] *Main> :step Stopped at bla1.hs:6:1-31 _result :: Int = _ [bla1.hs:6:1-31] *Main> :step Stopped at bla1.hs:6:17-31 _result :: Int = _ x :: Int = 2 y :: Int = _ [bla1.hs:6:17-31] *Main> :step Stopped at bla1.hs:6:1-31 _result :: Int = _ [bla1.hs:6:1-31] *Main> :step Stopped at bla1.hs:6:17-31 _result :: Int = _ x :: Int = 1 y :: Int = 0 [bla1.hs:6:17-31] *Main> :step Stopped at bla1.hs:5:1-19 _result :: Int = _ [bla1.hs:5:1-19] *Main> :step Stopped at bla1.hs:5:17-19 _result :: Int = _ x :: Int = 1 [bla1.hs:5:17-19] *Main> :step Stopped at bla1.hs:5:1-19 _result :: Int = _ [bla1.hs:5:1-19] *Main> :step Stopped at bla1.hs:5:17-19 _result :: Int = _ x :: Int = 2 [bla1.hs:5:17-19] *Main> :step Stopped at bla1.hs:5:1-19 _result :: Int = _ [bla1.hs:5:1-19] *Main> :step Stopped at bla1.hs:5:17-19 _result :: Int = _ x :: Int = 3 [bla1.hs:5:17-19] *Main> :step 0 *Main>

1 0

How to throw an error if using "cabal-install" < version XYZ?
by Ryan Newton 23 May '13

23 May '13

A cabal-install bug <https://github.com/haskell/cabal/issues/1284> was fixed recently that pertains to building C libraries with profiling. As a result, I want a certain package<http://hackage.haskell.org/package/atomic-primops-0.1.0.2>to test if cabal-install < 0.17.0 is used, and throw a preemptive error. Otherwise this package fails in weird ways at runtime (it's a nasty one). I noticed with some surprise the following sequence: * $ cabal --version* * cabal-install version 1.16.0.2* * using version 1.16.0.3 of the Cabal library* * $ cabal clean* * $ cabal install* * $ cat dist/build/autogen/cabal_macros.h | grep VERSION_Cabal* * #define VERSION_Cabal "1.17.0"* Alright, so that, in retrospect, makes sense. The version is which *my* library is linked with is the relevant one, not the one cabal-install was linked with [1]. So the natural next thought is to move the MIN_VERSION_Cabal test into Setup.hs, and force cabal to use it by setting the build type to Custom. But... I just learned from this ticket that the cabal macros are not available in Setup.hs: http://hackage.haskell.org/trac/hackage/ticket/326 Uh oh, what's left? -Ryan [1] P.S. Personally I'm now using a bash function like below, to force the two versions to be the same: function safe_cabal_install () { VER=`cabal --version | tail -n1 | awk '{ print $3 }'` cabal install --constraint="Cabal==$VER" $* }

3 4