- Haskell-Cafe - Haskell.org

Type classes
by Johannes Gerer 28 May '13

28 May '13

Dear Haskellers, While trying to understand the interconnection and hierarchy behind the important typeclasses, I stumbled upon the following question that I am not able to answer: There seems to be a hierachy of the type classes, in the sense, that the more powerfull a class is, the more fleixblility you have for combining them to complex programs. (Functor -> Applicative -> Arrow[Choice,Plus,Apply,..] -> Monad). It was nice to read in the Typeclassopedia, that ArrowApply and Monad are equivalent, which is shown by deriving two instances from each other: instance Monad m => ArrowApply (Kleisli m) instance ArrowApply a => Monad (a anyType) The logic seems to be, that if I can derive from every instance of class A an instance of class B, then A is more powerfull than B and (in general) it is easier to be of class B than of class A (e.g. more types can be made Applicatives, than Monads) So far, I think I can follow. But what really hit me was the Cokleisli type. Using it and the logic from above, I can show that ANY type class is more (or equally) powerfull than the Monad: instance AnyClass m => Monad (Cokleilsi m anyType) I know this makes no sense, but where is the fallacy? Why even bother with the above derivation, if any type class can be made into a monad? I can see, that the Monad instance from above does not really transform the type "a", but instead simply fix its first argument. But then on the other hand, the ArrowApply Instance does transform the "m" type (in a way similar to Cokleisli). If attention needs to be paid to the details, then what are they and why did they not matter above? Thanks, Johannes

3 10

Stream instance for Parsec + conduits
by Phil Scott 28 May '13

28 May '13

Hi all. I would like to have a Parsec Stream instance for Data.Text streams in yesod's ConduitM. So far, I have this: hpaste.org/87599 The idea is that because Yesod's conduits will be chunking values in Data.Text, I should have a wrapper StreamSource to cache chunked values. For some reason, the test parser fails, saying: [Left "Blah" (line 1, column 1): unexpected "g" expecting "h" or "g"] Any ideas? Cheers! Phil

2 1

Interfacing Java/Haskell
by Hans Georg Schaathun 28 May '13

28 May '13

Hi all, I am rather new to the café, so I just hope my question fits in. Does anyone have experience with integrating Haskell and Java? I have done some searching, finding a lot of pointers but hardly anything in terms of evaluation, successes, or caveats. >From what I see Frege looks promising, arguably not haskell I suppose, but does it work? Other projects I have seen appear to have reached a stand-still for ages. The background for the question is that I will contribute some control algorithms based on machine learning or AI in a larger project. It would save me a lot of time if I could write in Haskell, but only assuming that interfacing with Java afterwards is trivial compared to writing everything in java in the first place. I am, perhaps, particularly worried that a Haskell-lookalike for JVM might be unable to optimise properly, like not being lazy. Any advice? TIA -- :-- Hans Georg

8 13

Module import and use in GHC plugin?
by Conal Elliott 28 May '13

28 May '13

In writing GHC plugins, how can I (a) add a module import (preferably qualified) and (b) make vars/ids for names imported from the newly imported module (to insert in the transformed Core code)? Thanks, - Conal

1 0

Generalizing unionWithKey, unionWith, ...
by Jose A. Lopes 28 May '13

28 May '13

Hello everyone, unionWithKey and unionWith have the following types unionWith :: Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a unionWithKey :: Ord k => (k -> a -> a -> a) -> Map k a -> Map k a -> Map k a Since they are implemented by means of mergeWithKey, wouldn't it be possible to generalize these functions to the following types ? unionWith :: Ord k => (a -> b -> c) -> Map k a -> Map k b -> Map k c unionWithKey :: Ord k => (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c Cheers, Jose -- José António Branquinho de Oliveira Lopes Instituto Superior Técnico Technical University of Lisbon

3 4

Re: [Haskell-cafe] ANN: Haskell Platform 2013.2.0.0
by harry 28 May '13

28 May '13

Good to see it released! Was there a deliberate decision not to build a Windows x64 platform, or is it just that there wasn't anyone to do it?

1 0

Munich Haskell Meeting
by Heinrich Hördegen 28 May '13

28 May '13

Dear all, once again, our monthly Haskell Meeting in Munich will take place. We meet on Thursday, 30 of May, 19h30. The venue is as usually, Cafe Puck. Please go here for details and click the button if you plan to join: http://www.haskell-munich.de/dates Have a successful day! Heinrich

1 0

ANN: Haskell Platform 2013.2.0.0
by Mark Lentczner 28 May '13

28 May '13

On behalf of the Haskell Platform team, I'm happy to announce the release of Haskell Platform 2013.2.0.0 *featuring* GHC 7.6.3 52 packages 650+ public modules 4 tools *New packages this release:* attoparsec case-insensitive hashable unordered-containers *and a major upgrade to* OpenGL and GLUT Get it now: Download Haskell Platform <http://www.haskell.org/platform/index.html> — for Windows <http://www.haskell.org/platform/windows.html> — for Mac OS X <http://www.haskell.org/platform/mac.html> — for Linux <http://www.haskell.org/platform/linux.html> (distributions updating soon) *N.B.: You will likely need to explicitly re-fresh those links when visiting in your browser - those pages tend to get cached for very long periods of time.* — Mark "platform wrangler" Lentczner

1 0

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 117, Issue 40
by Diego Saa-temp 28 May '13

28 May '13

Sent from my Verizon Wireless 4G LTE smartphone -------- Original Message -------- Subject: Haskell-Cafe Digest, Vol 117, Issue 40 From: "haskell-cafe-request(a)haskell.org" <haskell-cafe-request(a)haskell.org> Date: Mon, 27-May-2013 06:00 To: "haskell-cafe(a)haskell.org" <haskell-cafe(a)haskell.org> CC: Send Haskell-Cafe mailing list submissions to haskell-cafe(a)haskell.org To subscribe or unsubscribe via the World Wide Web, visit http://www.haskell.org/mailman/listinfo/haskell-cafe or, via email, send a message with subject or body 'help' to haskell-cafe-request(a)haskell.org You can reach the person managing the list at haskell-cafe-owner(a)haskell.org When replying, please edit your Subject line so it is more specific than "Re: Contents of Haskell-Cafe digest..."

1 0

hackage update brigade (was Re: ANNOUNCE: new bridge! (prelude-prime))
by Evan Laforge 27 May '13

27 May '13

> Yes, it would break code. Probably a lot of code. So of course I volunteer to fix my code, but that's not much help, since it's a small minority of the code on hackage. So that made me think, maybe we should organize a kind of hackage community service brigade, which, when the time is right, would spring into action. They would download sections of hackage, update the code, and send patches to the maintainers. Then they'd keep track of which packages actually applied the patch, and that could go on an "update status" page. I'd sign up for that. Of course, package maintainers might prefer to do the change themselves, or more likely may be incommunicado. But the presence of a small army of organized volunteers waiting to update code might reduce friction to make necessary changes, and would take the weight off the shoulders of the few who wind up doing it anyway when a new ghc comes out. If people think this is a good idea, I volunteer to do the setup. I guess this means a short doc describing the process, and then a place where volunteers can sign up, and then keep the volunteer list up to date.

3 2

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

question about type constructors
by TP 23 May '13

23 May '13

Hi, In the program I am trying to write, I have a problem that can be reduced to the following dummy example: -------------------------- {-# LANGUAGE GADTs #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE IncoherentInstances #-} class PrettyPrint a where prettify :: a -> String data Gender = Male | Female | Gender3 | Gender4 data Person :: Gender -> * where Person :: String -> Person b Child :: String -> Person a -> Person b -> Person c instance PrettyPrint (Person a) instance PrettyPrint (Person Male) where prettify (Person name) = "My name is " ++ (show name) ++ " and I am a male" prettify (Child name person1 person2) = "My name is " ++ (show name) ++ " and my parents are:" ++ (prettify person1) ++ ", " ++ (prettify person2) main = do let p1 = Person "Jim" :: Person Male let p2 = Person "Joe" :: Person Male let p3 = Child "Jack" p1 p2 print $ prettify p1 print $ prettify p2 print $ prettify p3 -------------------------- The idea is that I want to implement PrettyPrint only for a subset of the possible types in Gender (through promotion process). Why? It would be longer to explain (it is a bit more complicated in my real program). Anyway, in the program above, I have found that with IncoherentInstances (and the empty instance definition for (Person a)), it is working, it is able to use the most specific instance corresponding to the current type (I don't know exactly why). For example, p1 and p2 are correctly printed above, because they are of type (Person Male) and because I have implemented PrettyPrint for (Person Male). But it does not work for p3, I obtain an error at runtime: ----- $ runghc test.hs "My name is \"Jim\" and I am a male" "My name is \"Joe\" and I am a male" test_typelost.hs: test_typelost.hs:16:10-31: No instance nor default method for class operation Main.prettify ----- The reason is that the information that p1 and p2 are Male seems to be "lost" when we construct the child "Child "Jack" p1 p2", probably because GHC only sees that in the type signature of Child, we have a more general (Person a) -> (Person b). So he tries to find an implementation of prettify in PrettyPrint (Person a), but there is none. Is there any workaround? Thanks, TP

2 3

[ANN] Hac Phi 2013
by Daniel Wagner 23 May '13

23 May '13

Hac Phi 2013, a Haskell hackathon/get-together, will be held June 7-9 at the University of Pennsylvania in Philadelphia. The hackathon will officially kick off at 2:30 Friday afternoon, and go until 5pm on Sunday (with breaks for sleep, of course). Last year's Hac Phi was a lot of fun, drawing more than 30 Haskellers, and many people have already expressed interest in coming back this year. Everyone is welcome - you do not have to be a Haskell guru. Helping hack on someone else's project could be a great way to increase your Haskell-fu. If you plan on coming, please officially register [1]. Registration, travel, lodging and many other details can be found on the Hac Phi wiki [2]. This year, we are making a public list of attendees' names and nicks - please let us know if you'd prefer not to be listed when you register. We're also looking for a few people interested in giving short (15-20 min.) talks, probably on Saturday afternoon. Anything of interest to the Haskell community is fair game - a project you've been working on, a paper, a quick tutorial. If you'd like to give a talk, add it on the wiki [3]. Hope to see you in Philadelphia! - The Hac Phi team Brent Yorgey (byorgey) Daniel Wagner (dmwit) Chris Casinghino (ccasin) [1] http://www.haskell.org/haskellwiki/Hac_%CF%86/Register [2] http://www.haskell.org/haskellwiki/Hac_%CF%86 [3] http://www.haskell.org/haskellwiki/Hac_%CF%86/Talks

1 1

Second Call for Papers: Workshop on Functional Art, Music, Modeling, and Design (colocated with ICFP)
by Brent Yorgey 23 May '13

23 May '13

Please submit something to FARM --- the deadline is fast approaching! ====================================================================== FARM 2013: Call for Papers ACM SIGPLAN Workshop on Functional Art, Music, Modeling and Design Boston, Massachusetts, USA 28th September, 2013 (directly after ICFP) http://www.cis.upenn.edu/~byorgey/farm13/ ====================================================================== Scope ----- The functional programming community is largely interested in writing beautiful programs. This workshop is intended to gather researchers and practitioners interested in writing beautiful programs that generate beautiful artifacts. Such artifacts may include visual art, music, 3D sculptures, animations, GUIs, video games, physical models, architectural models, choreographies for dance, poetry, and even physical objects such as VLSI layouts, GPU configurations, or mechanical engineering designs. The framework used need not be purely functional (“mostly functional” is fine); may be based on abstractions such as higher-order functions, monads, arrows, or streams; and may be manifested as a domain specific language or tool. Theoretical foundations, language design, implementation issues, and applications are all within the scope of the workshop. Important dates --------------- - Submissions due: Friday, 14 June 2013, 23:59 UTC-11 (American Samoa time [1]) - Author notification: Thursday, 11 July 2013 - Final papers due: Thursday, 25 July 2013 - Workshop: Saturday, 28 September 2013 (the day after ICFP) [1] http://www.timeanddate.com/worldclock/fixedtime.html?msg=FARM+submissions+d… Proceedings ----------- There will be a formal proceedings published by ACM Press. Accepted papers will be included in the ACM Digital Library; see http://authors.acm.org/main.cfm for information on the options available to authors. Authors are also encouraged to submit auxiliary material for publication along with their paper (source code, data, videos, images, etc.); authors retain all rights to the auxiliary material. Submission details ------------------ We solicit submissions in two categories: - Full papers. A full paper is limited to 12 pages, and will be evaluated according to its relevance, correctness, significance, originality, and clarity. It should explain its contributions, identify what has been accomplished, explain why it is significant, and compare it with previous work. - "Aesthetic applications". An aesthetic application paper is limited to 6 pages, and will be judged primarily on the effective and elegant use of FP to generate aesthetic artifacts (though the criteria for full papers are still relevant). Submitted papers should be in portable document format (PDF), formatted using the ACM SIGPLAN style guidelines. The text should be in a 9-point font in two columns. Submissions can be made via EasyChair at https://www.easychair.org/conferences/?conf=farm2013 Organizers ---------- Workshop Chair: Paul Hudak Program Chair: Conal Elliott Publicity Chair: Brent Yorgey Program Committee ----------------- Daniel Cukier (University of São Paulo) Conal Elliott (Tabula) (chair) Kathleen Fisher (Tufts University) Richard Gabriel (IBM Research) George Giorgidze (University of Tübingen) Paul Hudak (Yale University) José Pedro Magalhães (University of Oxford) Alex McLean (University of Leeds) John Peterson (Western State Colorado University) Michael Sperber (Active Group) Henning Thielemann Brent Yorgey (University of Pennsylvania)

1 0

"Haskell from N00b to Real World Programmer"
by Mihai Maruseac 22 May '13

22 May '13

Hello, As hinted in the previous HCAR, this year we will organize an workshop entitled like the subject of this mail[1]. It will be organized by ROSEdu (Romanian Open Source Education) [2] and the newly founded Haskell-Romania group (no link yet, working on that). It is one workshop in a series of summer workshops organized by ROSEdu (go one level up in the wiki, some of them are in Romanian and I don't want to blindly give links to Romanian pages). The entire schedule is given on the wiki page at [1] and detailed below: Day 1 (8th of July) Introduction. History and Syntax. -- basic introduction to the language. Including @lambdabot usage as an example Programming with Static Typing as An Ally. -- designing with types and using GHCI for rapid prototyping and testing type of expressions. Possible to include @djinn Programming with State and Style. -- gentle introduction to monads in the style of "You could have invented monads" [3] Day 2 (9th of July) Packaging and Distributing Code. -- hackage, cabal, cabal-dev and, maybe, stackage The Awesome xmonad Window Manager -- we'll let them tweak configuration files in xmonad and use them. In this way, they get to use real world apps and change them to suit their needs. Maybe attract some developers. Compare and Contrast. Blow Your Mind with Haskell and Compare with Python. -- Starting with a comparison between some Python code and the equivalent Haskell one we get to cover topics in [4] Day 3 (11th of July) Lenses for Updating Details. -- you've guessed it, lenses Creating Graphical Interfaces. -- GTK2hs or lGTK. I'd like to test the second one Static Site Generation. -- Hakyll, config tweaking, generating first site, etc. Day 4 (12th of July) Beautiful Diagrams -- diagrams package Pipes and Conduits for Faster I/O -- pipes Creating Real-World Web Applications. -- Yesod (because that's what we know) Day 5 (13th of July) Hackathon Day If you have some suggestions, please make them. Lastly, for the hackathon day we have considered making some bots for I.GameBot[5] and an IRC bot with features that we'd like on #rosedu and #haskell-ro (grab, karma, resource location, statistics). If you'd have some other suggestions which could be implemented in a single day after the previous courses, please, do share them with us. Thanks and sorry for the length of the mail. [1]: http://workshop.rosedu.org/2013/sesiuni/haskell [2]: http://rosedu.org/ [3]: http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html [4]: http://www.haskell.org/haskellwiki/Blow_your_mind [5]: https://github.com/rosedu/I.GameBot -- MM "All we have to decide is what we do with the time that is given to us"

2 1

Functional JavaScript Opportunity in NYC
by Ryan Trinkle 22 May '13

22 May '13

Hi everyone, Our company, skedge.me, is looking for a full-time front-end developer in the NYC area. Our front-end is written in JavaScript, but our back-end is written in Haskell, so we're looking for people with solid JavaScript experience but also a strong interest in functional programming. No work experience in Haskell is required, but we do require all applicants to submit a small code sample - something on the scale of a Project Euler problem - in a statically-typed functional language in addition to a more traditional JavaScript code sample. We write all of our JavaScript in a functional style, and we use the Google Closure compiler to provide some type checking for us, so we're looking for people who enjoy working in an environment with a bit more structure than the average JavaScript project. For more information or to apply, visit http://skedge.me/careers or contact me at ryan(a)skedge.me. Ryan Trinkle

1 0

accessing a type variable in instance declaration
by TP 22 May '13

22 May '13

Hi all, I wonder if there is some means to get a type variable value in the body of a class instance definition. It seems it is not possible (a workaround has already been given on this list), but I would like a confirmation. For example, imagine that I have a Tensor type constructor, that takes a type-level integer (representing the Tensor order) to make a concrete type: --------- instance Show (Tensor order) where show TensorVar str = show "tensor " ++ str ++ " of order " ++ (show (c2num order)) ---------- where c2num transforms a type-level integer to an integer, through typeclasses (see http://www.haskell.org/haskellwiki/The_Monad.Reader/Issue5/Number_Param_Typ…) I obtain a compilation error: order is not known in the body of the instance. Putting ScopedTypeVariable as extension does not change anything (http://www.haskell.org/ghc/docs/7.0-latest/html/users_guide/other-type-exte…) I have tried also using forall, without more success: ------------ instance forall order. Show (Tensor order) where show TensorVar str = show ”tensor ” ++ str ++ ” of order ” ++ (show (c2num order)) ------------ Thanks in advance, TP

2 3

Infrastructure for testing the impact of a Functor/Applicative/Monad hierarchy
by Niklas Hambüchen 22 May '13

22 May '13

Reading the other thread (Adding Applicative/Functor instances to all Monads in GHC) I was wondering if there was infrastructure for testing what effect making the often-discussed Functor/Monad change would have: How many packages on hackage would break etc. I have read a few times that people have "compiled all of hackage" to see the impact of whatever. How do you do that? Do you just run a loop around cabal install or have you built some more advanced tools to visualize the results better or compile the packages "from ground up", in order of their dependencies? I'm interested in anything in this direction.

3 3

Teaching FP with Haskell
by Rustom Mody 21 May '13

21 May '13

We are offering a MOOC on haskell : https://moocfellowship.org/submissions/the-dance-of-functional-programming-… Full Announcement on beginners list : http://www.haskell.org/pipermail/beginners/2013-May/012013.html One question that I have been grappling with in this regard: How to run ghc in lightweight/beginner mode? 2 examples of what I mean: 1. gofer used to come with an alternative standard prelude -- 'simple.pre' Using this, gofer would show many of the type-class based errors as simple (non-type-class based) errors. This was very useful for us teachers to help noobs start off without intimidating them. 2. Racket comes with a couple of levels. The easier numbers were not completely consistent with scheme semantics, but was gentle to beginners Any thoughts/inputs on this will be welcomed Rusi

4 3

parsing a CSV file
by Roger Mason 21 May '13

21 May '13

Hello, I'm attempting to write a parser for files that look like this: Bruker Nano GmbH Berlin, Germany Esprit 1.9 Date: 02/05/2013 10:06:49 AM Real time: 15000 Energy Counts -0.474 0 ..... The line before the ellipsis is repeated many times (such lines represents a spectrum). I need to be able to extract numbers from lines containing <string: > and I want to extract the number pairs following "Energy Counts\n". The extracted data will then be written to a file in a different format. For now I'll be satisfied with reading the "header" info, i.e. down to "Energy Counts\n". Thus far, I have: -- derived from RWH -- file: ch16/csv2.hs import Text.ParserCombinators.Parsec headerLines = endBy csvFile endHeader csvFile = endBy line eol line = sepBy cell (char ',') cell = many (noneOf ",\n") eol = char '\n' parseCSV :: String -> Either ParseError [[String]] parseCSV input = parse csvFile "(unknown)" input parseHDR :: String -> Either ParseError [[String]] parseHDR input = parse headerLines "(unknown)" input endHeader = string "Energy Counts" This loads into GHCi (7.6.2) OK. However, when I test it: parseHDR "Bruker Nano GmbH Berlin, Germany\nEsprit 1.9\n\nDate: 02/05/2013 10:06:49 AM\nReal time: 15000\nEnergy Counts" Not in scope: `parseHDR' which makes sense because ghci> :t endHeader <interactive>:1:1: Not in scope: `endHeader' Clearly, my naiive implementation of endHeader is no good. I appreciate any pointers. Thanks, Roger This electronic communication is governed by the terms and conditions at http://www.mun.ca/cc/policies/electronic_communications_disclaimer_2012.php

2 4

Announce: vsim the VHDL-subset simulator (unmaintained)
by Sergey Mironov 21 May '13

21 May '13

Hi. I'd like to announce the vsim - the simulator for (small subset of) VHDL language. Currently the project contains pretty large Java part and is not maintained. That's why I don't want to publish it on Hackage. Still, as far as I now have a permission to share the code, I would like to do it. https://github.com/grrwlf/vsim VSim is a VHDL simulator project aimed develop a methods of compiling VHDL code into a high-level language (Haskell). Currently it is able to compile simple VHDL programs, containing plain integer types, 1-dimentional arrays, records. It supports processes, procedures, functions (partly). Breakpoints and wait statements should work. Simulator compile VHDL into Haskell in several steps. Firstly, VHDL is translated into VIR-file by a translator written in Java (see tr/ folder and runtr function in ./simenv shell script). VIR file is lisp-like file, describing vhdl entities in a less complex manner. For example, it contains all the port maps expanded. Secondly, VSim tool is used to translate VIR into Haskell (see src/ folder and runsim functino in ./simenv). VSim is a small program which translates VIR line-by-line into Haskell program. haskell-src-exts is used to build the AST and print it to stdout. Finaly, Haskell program should be compiled into binary with ghc having runtime library included (refer to src\_r/ folder and runsim function in ./simenv). The runtime is the heart of the simulator and it's largest part. Java part is a main headache, because it is big, unsupported and has bugs lurking here and there. Haskell part is smaller and cleaner, but VHDL-standard coverage is still poor. For example, signal assignments are working as if they are declared with transport delay mechanism. Another problem is missing enum support except of some pre-defined. Sergey

1 0

Re: [Haskell-cafe] rip in the class-abstraction continuum
by oleg＠okmij.org 21 May '13

21 May '13

Type classes are the approach to constrain type variables, to bound polymorphism and limit the set of types the variables can be instantiated with. If we have two type variables to constrain, multi-parameter type classes are the natural answer then. Let's take this solution and see where it leads to. Here is the original type class > class XyConv a where > toXy :: a b -> [Xy b] and the problematic instance > data CircAppr a b = CircAppr a b b -- number of points, rotation angle, radius > deriving (Show) > > instance Integral a => XyConv (CircAppr a) where > toXy (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles To be more explicit, the type class declaration has the form > class XyConv a where > toXy :: forall b. a b -> [Xy b] with the type variable 'b' universally quantified without any constraints. That means the user of (toXy x) is free to choose any type for 'b' whatsoever. Obviously that can't be true for (toXy (CircAppr x y)) since we can't instantiate pi to any type. It has to be a Floating type. Hence we have to constrain b. As I said, the obvious solution is to make it a parameter of the type class. We get the first solution: > class XYConv1 a b where > toXy1 :: a b -> [Xy b] > > instance (Floating b, Integral a) => XYConv1 (CircAppr a) b where > toXy1 (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles The type class declaration proclaims that only certain combinations of 'a' and 'b' are admitted to the class XYConv1. In particular, 'a' is (CircAppr a) and 'b' is Floating. This reminds us of collections (with Int keys, for simplicity) > class Coll c where > empty :: c b > insert :: Int -> b -> c b -> c b > > instance Coll M.IntMap where > empty = M.empty > insert = M.insert The Coll declaration assumes that a collection is suitable for elements of any type. Later on one notices that if elements are Bools, they can be stuffed quite efficiently into an Integer. If we wish to add ad hoc, efficient collections to the framework, we have to restrict the element type as well: > class Coll1 c b where > empty1 :: c > insert1 :: Int -> b -> c -> c Coll1 is deficient since there is no way to specify the type of elements for the empty collection. When the type checker sees 'empty1', how can it figure out which instance for Coll1 (with the same c but different element types) to choose? We can help the type-checker by declaring (by adding the functional dependency c -> b) that for each collection type c, there can be only one instance of Coll1. In other words, the collection type determines the element type. Exactly the same principle works for XYConv. > class XYConv2 a b | a -> b where > toXy2 :: a -> [Xy b] > > instance (Floating b, Integral a) => XYConv2 (CircAppr a b) b where > toXy2 (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles The third step is to move to associated types. At this stage you can consider them just as a different syntax of writing functional dependencies: > class XYConv3 a where > type XYT a :: * > toXy3 :: a -> [Xy (XYT a)] > > instance (Floating b, Integral a) => XYConv3 (CircAppr a b) where > type XYT (CircAppr a b) = b > toXy3 (CircAppr divns ang rad) = > let dAng = 2 * pi / (fromIntegral divns) in > let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in > map (\a -> am2xy a rad) angles The step from XYConv2 to XYConv3 is mechanical. The class XYConv3 assumes that for each convertible 'a' there is one and only Xy type 'b' to which it can be converted. This was the case for (CircAppr a b). It may not be the case in general. But we can say that for each convertible 'a' there is a _class_ of Xy types 'b' to which they may be converted. This final step brings Tillmann Rendel's solution.

1 0

ghc-mod v2.0.1
by Kazu Yamamoto 21 May '13

21 May '13

Hi cafe! I have released ghc-mod v2.0.1. From this version, ghc-mod provides the ghc-mod library in addition to the ghc-mod command: http://hackage.haskell.org/package/ghc-mod http://mew.org/~kazu/proj/ghc-mod/en/ Enjoy! --Kazu

3 4

type-level integers for GHC
by Takayuki Muranushi 21 May '13

21 May '13

What is your recommendation for type-level integers? I'd like to use it to improve the unittyped, https://bitbucket.org/xnyhps/haskell-unittyped/ the library for physical dimension. Therefore, I need negative numbers, additions, but multiplications are not necessary. I've been looking forward for the type-nats extension of GHC, but I haven't been able to compile the type-nats branch. Just learned that it still takes a few month to merge the branch into the main. http://hackage.haskell.org/trac/ghc/wiki/Status/May13 Thijs, the original author of unittyped, has commited a branch that uses type-nats, but I can't try that out for the same reason. Best, -- Takayuki MURANUSHI The Hakubi Center for Advanced Research, Kyoto University http://www.hakubi.kyoto-u.ac.jp/02_mem/h22/muranushi.html

3 5

rip in the class-abstraction continuum
by Christopher Howard 21 May '13

21 May '13

Hi. I won't pretend to be an advanced Haskell programmer. However, I have a strong interest in abstraction, and I have been playing around with programming as abstractly as possible. Naturally, I find classes to be quite attractive and useful. However, something is bothering me. Lately I keep running into this situation where I have to cut across abstraction layers in order to make the code work. More specifically, I keep finding that I have to add constraints to a class definition, because eventually I find some instance of that class which needs those constraints to compile. For example, I wanted to create a class which represents all things that can be converted into X,Y coordinates. Naturally, I would like to do something like this: code: -------- class XyConv a where toXy :: a b -> [Xy b] -------- This leaves me free in the future to use any number type conceivable in the Xy coordinates - Floating or Integral types, or whatever. (Doesn't even have to be numbers, actually!) However the first instance I create, requires me to use operators in the function definition which require at least a Floating type. (The error will say Fractional, but there are other components that also require Floating.) code: -------- data CircAppr a b = CircAppr a b b -- number of points, rotation angle, radius deriving (Show) instance Integral a => XyConv (CircAppr a) where toXy (CircAppr divns ang rad) = let dAng = 2 * pi / (fromIntegral divns) in let angles = map ((+ ang) . (* dAng) . fromIntegral) [0..divns] in map (\a -> am2xy a rad) angles -------- This gives me the error code: -------- Could not deduce (Fractional b) arising from a use of `/' from the context (Integral a) bound by the instance declaration at /scratch/cmhoward/pulse-spin/pulse-spin.hs:51:10-42 Possible fix: add (Fractional b) to the context of the type signature for toXy :: CircAppr a b -> [Xy b] or the instance declaration In the expression: 2 * pi / (fromIntegral divns) In an equation for `dAng': dAng = 2 * pi / (fromIntegral divns) In the expression: let dAng = 2 * pi / (fromIntegral divns) in let angles = map ((+ ang) . (* dAng) . fromIntegral) [0 .. divns] in map (\ a -> am2xy a rad) angles -------- I can get a quick fix by adding Floating to the context of the /class/ definition: code: -------- class XyConv a where toXy :: Floating b => a b -> [Xy b] -------- But what I really want is to put Floating in the context of the /instance/ declaration. But I don't know how to do that syntactically. -- frigidcode.com

2 2

Failure deriving MonadRWS when using a type-family for the State part
by Nicolas Trangez 21 May '13

21 May '13

All, The following code results in a compilation error (I tried GHC 7.4.1 & a 7.7.20130430 build): {-# LANGUAGE TypeFamilies, GeneralizedNewtypeDeriving, StandaloneDeriving #-} module Main where import Control.Applicative import Control.Monad.RWS data C = C data E = E data S1 = S1 Int type family I a :: * type instance I S1 = Int newtype T a s m r = T { unT :: RWST C [E] (I s) m r } deriving ( Functor , Applicative , Monad , MonadReader C , MonadWriter [E] , MonadState (I s) , MonadRWS C [E] (I s) , MonadTrans ) Error: No instance for (MonadState (I s) (T a s m)) arising from the 'deriving' clause of a data type declaration Possible fix: use a standalone 'deriving instance' declaration, so you can specify the instance context yourself When deriving the instance for (MonadRWS C [E] (I s) (T a s m)) Commenting out the MonadRWS line from the derivings list (i.e. the line pointed at by the error) works as expected. I was somehow unable to get a suitable standalone-deriving clause working, so didn't test that. Is this expected? Regards, Nicolas

1 1

Stuck on design problem
by Nicolas Trangez 21 May '13

21 May '13

All, Since I'm stuck on a coding problem and can't figure out how to proceed, I decided to call for help. I'm unable to get some code to typecheck, so maybe I'm missing something obvious on the implementation side, or more likely the design is completely wrong. Here's the idea: I have some code which uses some log of "Entry a" values (for some polymorphic type 'a'), and provides actions which output "Command a" values which should be interpreted by some wrapper code, e.g. adding some new entries to the log. These actions are implemented in a custom WriterT transformer (in this demo code, the original is more complex) to output Commands, while the inner monad should give access to the log entries (this could be in-memory like in the example, or stored on disk so using IO). You can find a trimmed-down version at https://gist.github.com/NicolasT/4230251f4f87f110d197 This doesn't type-check, and I'm not sure how to proceed. Am I taking a wrong approach? Do I need a different design? Thanks, Nicolas

3 4

DSL to English and back for game rule set?
by Matthew O'Connor 20 May '13

20 May '13

Hello all, I recognize this isn't directly a Haskell-related question, but as I'd like to solve this problem in Haskell & figured it's applicable. Let me know if there's a better place to ask. I am interested in creating a DSL (or set of types) for describing rules for a computer game. I'd like the language to be able to be written out to readable and clear English. I'd also like to be able to recreate the representation by reading the English back in. The idea is that the DSL will be unambiguous in either English or its internal representation. My thinking is that this will avoid inconsistencies between the game rules and the text describing those rules to the players. I want the ruleset to be able to describe type of heroes and monsters, their abilities, the effects of their attacks, how they use resources, etc. I realize this may not be an efficient way to go about writing a game, but it seems like an interesting project. Some of my concerns are at what level the DSL should be written to allow for extensions for new heroes, monsters, etc. without having to just add very specific extensions every time a new hero or item is created. Does anyone have thoughts on how to proceed on this, previous work, and/or ways to investigate it? Thanks, Matthew

4 3

New Functional Programming Job Opportunities
by Functional Jobs 20 May '13

20 May '13

Here are some functional programming job opportunities that were posted recently: Test Engineer at Klarna http://functionaljobs.com/jobs/146-test-engineer-at-klarna Cheers, Sean Murphy FunctionalJobs.com

1 0

ANN: lambdabot-4.3
by James Cook 20 May '13

20 May '13

As discussed a couple months ago, I have assumed maintainership of Lambdabot and a a new release has been brewing for a while. It has now been Hackaged as lambdabot-4.3. There are quite a few changes in this release, mainly internal. Plugins written for older versions will require some fairly straightforward rewriting - the plugin interface is now based on a record rather than a type class, and makes use of some simple monad transformers to stabilize the API a bit in the face of future changes. There are many things I'd like to do to continue modernizing it, the most significant of which being that I'd like to overhaul the state storage system and break it down into smaller packages. Therefore, plugin-writers should consider this a bit of a stepping-stone release - in the not too distant future, another release will probably break the plugin API again. If you have open-source plugins, please let me know and I'll feed you patches to keep up with any changes coming down the pipeline. The most significant changes from the user's perspective are probably the expanded command line interface (try --help) and the changes to the eval plugin. Eval now uses Safe Haskell, and accepts a much wider array of user-supplied code - the "@let" command now accepts module imports, type declarations, class declarations, and instances, and will add clauses to existing function definitions when applicable. I apologize in advance that the documentation is still mostly in a state of non-existence. If anyone runs into issues, please report them to me. I can be reached through the following channels: - github "issues"[1] - e-mail, at this address - #haskell (I'm "mokus" there) - I'm not often present, but pretty much always connected and will see and eventually respond to PRIVMSGs. [1] https://github.com/mokus0/lambdabot/issues

1 0

More general "pattern matching"
by Tom Ellis 20 May '13

20 May '13

Suppose I have a Category C > import Prelude hiding ((.), id) > import Control.Category > > data C a b > > instance Category C where > (.) = undefined > id = undefined which has "products" in the sense that there exists a "factors" function with suitable properties > factors :: C a (b, c) -> (C a b, C a c) > factors = undefined Then I can define this interesting combinator > (~~) :: (C a b -> r) -> (C a c -> r') -> C a (b, c) -> (r, r') > (f ~~ g) h = let (l, r) = factors h in (f l, g r) which allows some form of "pattern matching", for example > a :: C z a > b :: C z b > c :: C z c > d :: C z d > e :: C z e > ((a, b), (c, (d, e))) = ((id ~~ id) ~~ (id ~~ (id ~~ id))) undefined and even > w :: C a w > x :: C a x > y :: C a y > z :: (C a z, C a z') > ((w, x), (y, z)) = ((id ~~ id) ~~ (id ~~ (id ~~ id))) undefined Does anyone have anything to say about this? I'm sure others must have come across it before. There's something very lensy going on here too. There's nothing special about 'Category's here, but it's an example where the structure is demonstrated nicely. It's a shame that the structure of the pattern must be duplicated on the left and right of the binding. Tom

1 0

Re: [Haskell-cafe] partially applied data constructor and corresponding type
by Stephen Tetley 18 May '13

18 May '13

What you probably want are type level integers (naturals) Yury Sulsky used them in the message above - basically you can't use literal numbers 1,2,3,... etc as they are values of type Int (or Integer, etc...) instead you have to use type level numbers: data One data Two Work is ongoing for type level numbers in GHC and there are user libraries on Hackage so there is a lot of work to crib from.

3 4

question about GADT and deriving automatically a Show instance
by TP 18 May '13

18 May '13

Hi everybody, I have a question about deriving automatically a Show instance when using GADT. It works in this situation: ---------------------------- {-# LANGUAGE GADTs #-} data Male data Female data Person gender where Dead :: Person gender Alive :: { name :: String , weight :: Float , father :: Person gender } -> Person gender deriving Show main = do let a = Alive "Joe" 60 Dead :: Person Male let b = Alive "Jim" 70 a :: Person Male print a print b ---------------------------- Indeed: $ runghc test_show.hs Alive {name = "Joe", weight = 60.0, father = Dead} Alive {name = "Jim", weight = 70.0, father = Alive {name = "Joe", weight = 60.0, father = Dead}} But when I replace "father :: Person gender" by "father :: Person gender2" in the code (this is one of the advantages of GADT: with a classical algebraic data type declaration, gender2 would have to be a type variable for the data type), I obtain: Can't make a derived instance of `Show (Person gender)': Constructor `Alive' must have a Haskell-98 type Possible fix: use a standalone deriving declaration instead In the data declaration for `Person' So I modify my code by removing "deriving Show", and adding the line: ---------------------------- instance Show (Person gender) ---------------------------- But now, I obtain: $ runghc test_show.hs GHC stack-space overflow: current limit is 536870912 bytes. Use the `-K<size>' option to increase it. Why (I imagine this is because there is an infinite loop in the construction of the show function)? Is there any workaround? Thanks, TP

4 6

Compiler error in Parsec using ByteString
by mukesh tiwari 18 May '13

18 May '13

Hello all, I am trying to write a small calculator using Parsec. Every thing went fine and I wrote this [1] and now I am trying to use ByteString to make it more faster but getting compiler error which I am not able to figure out. Could some one please tell me what is wrong with this code. In case of indentation error, code on hpaste[2] {-# LANGUAGE OverloadedStrings #-} import qualified Text.Parsec.Token as Token import Text.Parsec.Prim import Text.Parsec.Char import Text.Parsec.Expr import Text.Parsec.Combinator import Text.Parsec.Language import qualified Text.Parsec.ByteString.Lazy as T import qualified Data.ByteString.Lazy.Char8 as BS import Control.Applicative hiding ( ( <|> ) , many ) import Data.Maybe ( fromJust ) languageDef = emptyDef { Token.commentStart = "/*" , Token.commentEnd = "*/" , Token.commentLine = "//" , Token.nestedComments = False , Token.identStart = letter <|> char '_' , Token.identLetter = alphaNum <|> oneOf "_'" , Token.opStart = Token.opLetter emptyDef , Token.opLetter = oneOf ":!#$%&*+./<=>?@\\^|-~" , Token.reservedOpNames= ["*" , "/" , "^" , "+" , "-" ] , Token.reservedNames = [] , Token.caseSensitive = True } lexer = Token.makeTokenParser languageDef identifier = Token.identifier lexer reserved = Token.reserved lexer operator = Token.operator lexer reservedOp = Token.reservedOp lexer natural = Token.natural lexer integer = Token.integer lexer float = Token.float lexer lexeme = Token.lexeme lexer parens = Token.parens lexer whiteSpace = Token.whiteSpace lexer semi = Token.semi lexer comma = Token.comma lexer colon = Token.colon lexer dot = Token.dot lexer semiSep = Token.semiSep lexer commaSep = Token.commaSep lexer data Expr = Num Integer | Add Expr Expr | Sub Expr Expr | Mul Expr Expr | Div Expr Expr | Exp Expr Expr deriving Show exprCal :: T.Parser Expr exprCal = buildExpressionParser table factor table = [ [ op "^" Exp AssocRight ] , [ op "*" Mul AssocLeft, op "/" Div AssocLeft ] , [ op "+" Add AssocLeft, op "-" Sub AssocLeft ] ] where op s f assoc = Infix ( reservedOp s >> return f ) assoc factor :: T.Parser Expr factor = parens exprCal <|> Num <$> integer calExpression :: Expr -> Integer calExpression ( Num n ) = n calExpression ( Add e1 e2 ) = calExpression e1 + calExpression e2 calExpression ( Sub e1 e2 ) = calExpression e1 - calExpression e2 calExpression ( Mul e1 e2 ) = calExpression e1 * calExpression e2 calExpression ( Div e1 e2 ) = div ( calExpression e1 ) ( calExpression e2 ) calExpression ( Exp e1 e2 ) = calExpression e1 ^ ( calExpression e2 ) calculator :: String -> Integer calculator expr = case parse ( whiteSpace >> exprCal ) "" ( BS.pack expr ) of Left msg -> error "failed to parse" Right ( val ) -> calExpression val *Main> :load "/Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs" [1 of 1] Compiling Main ( /Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs, interpreted ) /Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs:56:36: Couldn't match type `[Char]' with `BS.ByteString' Expected type: OperatorTable BS.ByteString () Data.Functor.Identity.Identity Expr Actual type: [[Operator String () Data.Functor.Identity.Identity Expr]] In the first argument of `buildExpressionParser', namely `table' In the expression: buildExpressionParser table factor In an equation for `exprCal': exprCal = buildExpressionParser table factor /Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs:67:11: Couldn't match type `[Char]' with `BS.ByteString' Expected type: ParsecT BS.ByteString () Data.Functor.Identity.Identity Expr Actual type: ParsecT String () Data.Functor.Identity.Identity Expr In the return type of a call of `parens' In the first argument of `(<|>)', namely `parens exprCal' In the expression: parens exprCal <|> Num <$> integer /Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs:67:19: Couldn't match type `BS.ByteString' with `[Char]' Expected type: ParsecT String () Data.Functor.Identity.Identity Expr Actual type: T.Parser Expr In the first argument of `parens', namely `exprCal' In the first argument of `(<|>)', namely `parens exprCal' In the expression: parens exprCal <|> Num <$> integer /Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs:68:21: Couldn't match type `[Char]' with `BS.ByteString' Expected type: ParsecT BS.ByteString () Data.Functor.Identity.Identity Integer Actual type: ParsecT String () Data.Functor.Identity.Identity Integer In the second argument of `(<$>)', namely `integer' In the second argument of `(<|>)', namely `Num <$> integer' In the expression: parens exprCal <|> Num <$> integer /Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs:82:46: Couldn't match type `BS.ByteString' with `[Char]' Expected type: ParsecT String () Data.Functor.Identity.Identity Expr Actual type: T.Parser Expr In the second argument of `(>>)', namely `exprCal' In the first argument of `parse', namely `(whiteSpace >> exprCal)' In the expression: parse (whiteSpace >> exprCal) "" (BS.pack expr) /Users/mukeshtiwari/Programming/Code/Compilers/ParsecExample.hs:82:62: Couldn't match type `BS.ByteString' with `[Char]' Expected type: String Actual type: BS.ByteString In the return type of a call of `BS.pack' In the third argument of `parse', namely `(BS.pack expr)' In the expression: parse (whiteSpace >> exprCal) "" (BS.pack expr) Failed, modules loaded: none. Prelude> Mukesh Tiwari [1] http://hpaste.org/88155 [2] http://hpaste.org/88156

2 2

Extensible Records using Implicit Parameters
by Thomas Jaeger 18 May '13

18 May '13

Hello, Records in Haskell are somewhat of a contentious issue and many proposals have been put forth to address the shortcomings of the current record system [1]. Below, I introduce a small library relying on several GHC extensions, crucially Implicit Parameters and Constraint Kinds, which implements an extensible record system. While by no means production-ready, it is remarkably close to how I think an extensible record system should function. Record access is very convenient (reminiscent of Pascal's with statement), while record update is somewhat cumbersome (but could potentially be improved using Template Haskell). Two caveats: * Type inference for records does not work, so type signatures have to be provided. * When more than one binding for an implicit parameter is in scope, it is not always clear which one takes precedence. However, I think it is safe to assume that if the innermost binding is a let/where binding, it will carry the day. In all other cases, it is probably safest to rely on explicit type signatures to resolve the ambiguity. > {-# LANGUAGE ImplicitParams #-} > {-# LANGUAGE ConstraintKinds #-} > {-# LANGUAGE GADTs #-} > {-# LANGUAGE RankNTypes #-} The record type is simply the dictionary type, which is more commonly used to reify type class dictionaries. Here, we use it to record a number of implicit parameter bindings, i.e. if implicit parameters of types `fields' are in scope, then the data constructor `Rec' will create a dictionary from them, provided an appropriate type signature is given. > data Record fields where > Rec :: fields => Record fields The `?' operator will bring the implicit parameter bindings previously captured by `Rec' into scope. > infixr 1 ? > (?) :: Record fields -> (fields => r) -> r > Rec ? e = e This is the complete library. Examples follow below. ======================================================================== Type synonyms to replace the awkward syntax for implicit parameter constraints. > type X a = ?x::a > type Y a = ?y::a > type Z a = ?z::a As a first example, construct a record with fields ?x and ?y, both of type Int. > xy :: Record (X Int, Y Int) > xy = let ?x = 1; ?y = 2 in Rec To access the fields of the record, we can use the `?' operator. Expressions involving any of the fields can appear to the right of the operator. * xy ? ?x ==> 1 * xy ? ?x + ?y ==> 3 The next example illustrates record update > xy' :: Record (X Int, Y Int) > xy' = xy ? let ?y = -2 in Rec * xy' ? ?y ==> -2 Type signatures are required, but can be placed directly after `Rec'. > xz = let ?x = -1; ?z = 3 in Rec :: Record (X Int, Z Int) Record Restriction > y :: Record (Y Int) > y = xy ? Rec We can combine records as follows, but the result may be implementation- dependent if both records share fields. > xyz, xyz' :: Record (X Int, Y Int, Z Int) > xyz = xz ? xy ? Rec * xyz ? ?x ==> -1 So it is probably better to disambiguate. > xyz' = xz ? y ? Rec * xyz' ? ?x ==> -1 ======================================================================== As an application, we use records to build a rudimentary object system. A class is a record which can access its own fields, which are supplied as an argument. > type Class fields = Record fields -> Record fields Originally I tried the type 'fields => Record fields', which leads to problems when tying the knot. Given a class, we can get a record for property and method access by using a fixed point combinator. > runClass :: Class fields -> Record fields > runClass inst = inst (runClass inst) Type signatures for our next example. > type N = ?n::Int > type AbstractFact = (?fact::Int, ?factHelper::Int -> Int -> Int) > type ConcreteFact = (AbstractFact, N) This is an abstract class that computes the factorial of its abstract property `?n'. Notice how `?n' is not included in the function's return type. > abstractFact :: Record ConcreteFact -> Record AbstractFact > abstractFact r = Rec where > ?fact = r ? ?factHelper 1 ?n > ?factHelper = r ? > \p k -> if k == 1 then p else ?factHelper (p*k) (k-1) It is important that `r' only be opened inside the definitions of the methods, otherwise `runClass' will cause an infinite loop. To go from an abstract class to a concrete class, all we need to do is provide the missing property. > concreteFact :: Int -> Class ConcreteFact > concreteFact n r = abstractFact r ? let ?n = n in Rec Quick sanity check > testFact :: Class ConcreteFact > testFact = concreteFact 10 * runClass testFact ? ?fact ==> 3628800 Example of overloading. > overrideFact :: Class ConcreteFact > overrideFact r = testFact r ? let ?fact = fact in Rec where > fact = r ? product [1.. ?n] It is tempting to use the following definition overrideFact r = testFact r ? let ?fact = product [1.. ?n] in Rec However, this will use `?n' from the current environment and not respond to `?n' being overridden in a subclass. The final example concerns multiple inheritance. We first define a class for computing Fibonacci numbers, similar to the one for the factorial above. > type Fib = (?fib::Int, N) > fib :: Int -> Class Fib > fib n r = Rec where > ?n = n > ?fib = let fibs = 0:zipWith (+) fibs (1:fibs) in r ? fibs !! ?n A multiple-inheritance combinator > diamond :: Class c1 -> Class c2 -> Class (c1,c2) > diamond c1 c2 r = c1 (r ? Rec) ? c2 (r ? Rec) ? Rec > testFactFib :: Class (ConcreteFact, Fib) > testFactFib = diamond testFact (fib 5) This is C++-style inheritance: We now have two copies of the field `?n'. * runClass testFactFib ? ?fact ==> 3628800 * runClass testFactFib ? ?fib ==> 5 However, if we were to update `?n' in a subclass, both the factorial and the Fibonacci class would both use the new value. Alternatively, we can force the class to use a single value for `?n' by making sure `?n' only occurs once in the list of fields, but it's anyone's guess which value GHC will pick for `?n'. > testFactFib' :: Class (AbstractFact, Fib) > testFactFib' r = testFactFib (r ? Rec) ? Rec * runClass testFactFib' ? ?fact ==> 120 * runClass testFactFib' ? ?fib ==> 5 Thomas [1] http://hackage.haskell.org/trac/ghc/wiki/Records

1 0

A use case for *real* existential types
by oleg＠okmij.org 18 May '13

18 May '13

But Haskell (and GHC) have existential types, and your prototype code works with GHC after a couple of trivial changes: > main = do > W nd0 <- init > wd0 <- addWatch nd0 "foo" > wd1 <- addWatch nd0 "bar" > W nd1 <- init > wd3 <- addWatch nd1 "baz" > printInotifyDesc nd0 > printInotifyDesc nd1 > rmWatch nd0 wd0 > rmWatch nd1 wd3 > -- These lines cause type errors: > -- rmWatch nd1 wd0 > -- rmWatch nd0 wd3 > printInotifyDesc nd0 > printInotifyDesc nd1 The only change is that you have to write W nd <- init and that's all. The type-checker won't let the user forget about the W. The commented out lines do lead to type errors as desired. Here is what W is > data W where > W :: Inotify a -> W > init :: IO W [trivial modification to init's code] I must say though that I'd rather prefer Adres solution because his init > init :: (forall a. Inotify a -> IO b) -> IO b ensures that Inotify does not leak, and so can be disposed of at the end. So his init enforces the region discipline and could, after a trivial modification to the code, automatically do a clean-up of notify descriptors -- something you'd probably want to do.

2 2

Propositions in Haskell
by Patrick Browne 17 May '13

17 May '13

6 8

Lambda expressions (core) to categorical form
by Conal Elliott 17 May '13

17 May '13

I want to convert lambda expressions into a vocabulary of monoidal categories, so that they can be given multiple interpretations, including circuit generation and timing analysis, and hopefully some other far-out alternatives (3D visualization, animated evaluation, etc). More specifically, I want a GHC plugin that makes this transformation on GHC's Core language. If you know of related work, have suggestions, and/or are interested in collaborating/consulting, I'd love to hear. Thanks, - Conal

1 0

List comprehensions with Word8
by Jose A. Lopes 17 May '13

17 May '13

Hello everyone, I was playing with Word8 and list comprehensions and the following examples came up. I have to admit the behavior looks quite strange because it does not seem to be consistent. Can someone shed some light on reason behind some of these outputs? By the way, I have abbreviated some outputs with ellipsis ... [1..10] :: [Word8] [1,2,3,4,5,6,7,8,9,10] [1..100] :: [Word8] [1,2,3,4,5,6,7,8,9,10,...,100] [1..1000] :: [Word8] [1,2,3,4,5,6,7,8,9,10,...,232] [1..10000] :: [Word8] [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] [1..100000] :: [Word8] [1,2,3,4,5,6,7,8,9,10,...,160] [1..1000000] :: [Word8] [1,2,3,4,5,6,7,8,9,10,...,64] [1..10000000] :: [Word8] [1,2,3,4,5,6,7,8,9,10,...,128] [1..100000000] :: [Word8] [] [1..1000000000] :: [Word8] [] Thank you, Jose -- José António Branquinho de Oliveira Lopes Instituto Superior Técnico Technical University of Lisbon

5 4

Re: [Haskell-cafe] Infrastructure for testing the impact of a Functor/Applicative/Monad hierarchy
by Stephen Tetley 16 May '13

16 May '13

Has anyone surveyed the in-print textbooks, tutorials, or tried to assess how much Haskell (H98, H2010, Glasgow Haskell?) is used in teaching? Having the wrong hierarchy is a minor annoyance to us members of the cognoscenti, but a change outside a revision of the language standard could leave a lot of beginners and the teaching material they rely on stranded.

2 1

Parallel ghc --make
by Niklas Hambüchen 16 May '13

16 May '13

I know this has been talked about before and also a bit in the recent GSoC discussion. I would like to know what prevents ghc --make from working in parallel, who worked at that in the past, what their findings were and a general estimation of the difficulty of the problem. Afterwards, I would update http://hackage.haskell.org/trac/ghc/ticket/910 with a short summary of what the current situation is. Thanks to those who know more!

5 6