- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] indexed writer monad
by Doug McIlroy 09 Apr '15

09 Apr '15

I infer from the following dialog that ghci nontransparently caches knowledge about the contents of the library. This is doubtless helpful for the flurry of imports that a single "load" or interactive "import" may cause. But the time saved by caching from one such top-level action to the next is probably imperceptible. The hours wasted in the present instance and others like it (the very quick response on cafe suggests that it's not unusual) probably outweigh all the milliseconds that the cache normally saves. Non-transparent caching is inherently evil. While the risk may be justifiable in some cases (e.g. stdio buffers in C), it is very questionable at top level in ghci. Doesn't this warrant a ticket? Doug >> I install the indexed package by using cabal >> >> Cabal install indexed >> >> https://hackage.haskell.org/package/indexed >> >> Seemed to do something. >> >> Then I want to use that package... >> >>> import Control.Monad.Indexed >> >> Boom...unknown... > > Possibly silly question but... did you restart `ghci` after installing indexed? Genius Maybe this Haskell lark isnt as hard as I thought....

1 0

Generalized Newtype Deriving not allowed in Safe Haskell
by Omari Norman 09 Apr '15

09 Apr '15

When compiling code with Generalized Newtype Deriving and the -fwarn-unsafe flag, I get -XGeneralizedNewtypeDeriving is not allowed in Safe Haskell This happens both in GHC 7.8 and GHC 7.10. I thought I remembered reading somewhere that GNTD is now part of the safe language? The GHC manual used to state that GNTD is not allowed in Safe Haskell: https://downloads.haskell.org/~ghc/7.6.3/docs/html/users_guide/safe-haskell… But this language on GNTD not being part of the safe language was removed in the 7.8 manual: https://downloads.haskell.org/~ghc/7.8.2/docs/html/users_guide/safe-haskell… The GHC release notes don't say anything about this one way or the other. Thoughts?

2 1

Re: [Haskell-cafe] Distributed and persistent events bus in Haskell
by timmy tofu 08 Apr '15

08 Apr '15

We're working on something with 0MQ, if you (or anyone else reading) go that route and want to compare notes, hit me off-list. On Apr 8, 2015 8:01 AM, <haskell-cafe-request(a)haskell.org> wrote: > Send Haskell-Cafe mailing list submissions to > haskell-cafe(a)haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/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..." > > > Today's Topics: > > 1. Distributed and persistent events bus in Haskell (Arnaud Bailly) > 2. Re: Distributed and persistent events bus in Haskell > (Kyle Marek-Spartz) > 3. Re: Distributed and persistent events bus in Haskell > (Arnaud Bailly) > 4. Re: MinGHC for GHC 7.10.1 available (Aaron Contorer) > 5. status of deb.haskell.org? (Jeremy) > 6. help w/ improving custom Stream for parsec (Maurizio Vitale) > 7. Anyone interested in taking over network-uri? (Johan Tibell) > 8. Re: Anyone interested in taking over network-uri? (Alexey Shmalko) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Tue, 7 Apr 2015 16:50:49 +0200 > From: Arnaud Bailly <arnaud.oqube(a)gmail.com> > To: Haskell Cafe <haskell-cafe(a)haskell.org> > Subject: [Haskell-cafe] Distributed and persistent events bus in > Haskell > Message-ID: > < > CAL4zPaqpKXdOibD3_HECt%2B0V0ZniH0kKpA_ESQ30P7g9Ly_5cg(a)mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > Hello, > > I am implementing an application using event sourcing as primary storage > for data, which implies I need a way to durably and reliably store streams > of events on stable storage. I also need to be able to have an event > distribution system on top of that persistent storage so that components > can subscribe to stored events. > > So far I have implemented a simple store, e.g. a flat file, which reuses > the format of Apache Kafka (just in case...). Not very robust nor > sophisticated but can work for moderate loads. Now I am looking for the > event distribution part in the hope of being able to reuse some distributed > event bus system that might exist somewhere and not having to roll my own. > > I have had a look couple of months ago at Vaultaire, Marquise and friends, > but I am not sure they are really suited to my use case: They seem to be > geared toward very high workload and throughput, like log or huge data > streams analysis. > > Thanks for any pointer you might share, > -- > Arnaud Bailly > > twitter: abailly > skype: arnaud-bailly > linkedin: http://fr.linkedin.com/in/arnaudbailly/ >

1 0

ANN: hledger 0.25
by Simon Michael 08 Apr '15

08 Apr '15

I'm pleased to announce hledger and hledger-web 0.25. This release brings GHC 7.10 compatibility, terminal width awareness, useful averages and totals columns, and a more robust hledger-web add form. Full release notes: http://hledger.org/release-notes#hledger-0.25 . Release contributors: Simon Michael, Julien Moutinho. hledger (http://hledger.org) is a command-line tool and haskell library for tracking financial transactions, which are stored in a human-readable plain text format. It can also read CSV or timelog files. It provides useful reports, and can also help you record new transactions interactively. Add-on commands include hledger-web (a web interface), hledger-irr (for calculating internal rate of return) and hledger-interest (for generating interest transactions). hledger is inspired by and largely compatible with Ledger, and can be used with some Ledger files. Installation: cabal update; cabal install hledger [hledger-web] or see http://hledger.org/download and http://hledger.org/installing <http://hledger.org/installing> for more options. Best! -Simon

1 0

MinGHC for GHC 7.10.1 available
by Michael Snoyman 07 Apr '15

07 Apr '15

I've just uploaded a new release of MinGHC, including GHC 7.10.1 and cabal-install 1.22.2.0. This release can be downloaded from: https://s3.amazonaws.com/download.fpcomplete.com/minghc/minghc-7.10.1-i386.… In the process, I also needed to upload a cabal-install binary for Windows, which is available at: https://s3.amazonaws.com/download.fpcomplete.com/minghc/cabal-install-1.22.… I've tested this distribution, but only lightly. Feedback from others would be useful :)

2 1

Distributed and persistent events bus in Haskell
by Arnaud Bailly 07 Apr '15

07 Apr '15

Hello, I am implementing an application using event sourcing as primary storage for data, which implies I need a way to durably and reliably store streams of events on stable storage. I also need to be able to have an event distribution system on top of that persistent storage so that components can subscribe to stored events. So far I have implemented a simple store, e.g. a flat file, which reuses the format of Apache Kafka (just in case...). Not very robust nor sophisticated but can work for moderate loads. Now I am looking for the event distribution part in the hope of being able to reuse some distributed event bus system that might exist somewhere and not having to roll my own. I have had a look couple of months ago at Vaultaire, Marquise and friends, but I am not sure they are really suited to my use case: They seem to be geared toward very high workload and throughput, like log or huge data streams analysis. Thanks for any pointer you might share, -- Arnaud Bailly twitter: abailly skype: arnaud-bailly linkedin: http://fr.linkedin.com/in/arnaudbailly/

2 2

FFI Ptr Question
by Michael Jones 07 Apr '15

07 Apr '15

I am having trouble figuring out how to pass callbacks to C. Given the definition below it is not clear how to define a function and pass it. I tried: getNumberOfRows :: CInt getNumberOfRows = 1 table <- wxcGridTableCreate getNumberOfRows… but the compiler barks at me: src/MainGui.hs:577:32: Not in scope: data constructor ‘Ptr’ even through I do the imports: import Foreign import Foreign.C There is also a _obj as the first value of wxcGridTableCreate and the callbacks, and I am not sure how to make a this* for it. I would have throughout that wxcGridTableCreate would return a Ptr. The goal is to pass haskell functions into wxcGridTableCreate so the grid can call back to haskell. Can someone show an example of just this one function, how to wrap a Ptr around it, and what to do with _obj? DEFINITION wxcGridTableCreate :: Ptr a -> Ptr b -> Ptr c -> Ptr d -> Ptr e -> Ptr f -> Ptr g -> Ptr h -> Ptr i -> Ptr j -> Ptr k -> Ptr l -> Ptr m -> Ptr n -> Ptr o -> Ptr p -> Ptr q -> IO (WXCGridTable ()) wxcGridTableCreate _obj _EifGetNumberRows _EifGetNumberCols _EifGetValue _EifSetValue _EifIsEmptyCell _EifClear _EifInsertRows _EifAppendRows _EifDeleteRows _EifInsertCols _EifAppendCols _EifDeleteCols _EifSetRowLabelValue _EifSetColLabelValue _EifGetRowLabelValue _EifGetColLabelValue = withObjectResult $ wx_ELJGridTable_Create _obj _EifGetNumberRows _EifGetNumberCols _EifGetValue _EifSetValue _EifIsEmptyCell _EifClear _EifInsertRows _EifAppendRows _EifDeleteRows _EifInsertCols _EifAppendCols _EifDeleteCols _EifSetRowLabelValue _EifSetColLabelValue _EifGetRowLabelValue _EifGetColLabelValue foreign import ccall "ELJGridTable_Create" wx_ELJGridTable_Create :: Ptr a -> Ptr b -> Ptr c -> Ptr d -> Ptr e -> Ptr f -> Ptr g -> Ptr h -> Ptr i -> Ptr j -> Ptr k -> Ptr l -> Ptr m -> Ptr n -> Ptr o -> Ptr p -> Ptr q -> IO (Ptr (TWXCGridTable ())) typedef int _cdecl (*TGridGetInt)(void* _obj); typedef int _cdecl (*TGridIsEmpty)(void* _obj, int row, int col); typedef void* _cdecl (*TGridGetValue)(void* _obj, int row, int col); typedef void _cdecl (*TGridSetValue)(void* _obj, int row, int col, void* val); typedef void _cdecl (*TGridClear)(void* _obj); typedef int _cdecl (*TGridModify)(void* _obj, int pos, int num); typedef int _cdecl (*TGridMultiModify)(void* _obj, int num); typedef void _cdecl (*TGridSetLabel)(void* _obj, int idx, void* val); typedef void* _cdecl (*TGridGetLabel)(void* _obj, int idx); EWXWEXPORT(void*,ELJGridTable_Create)(void* self,void* _EifGetNumberRows,void* _EifGetNumberCols,void* _EifGetValue,void* _EifSetValue,void* _EifIsEmptyCell,void* _EifClear,void* _EifInsertRows,void* _EifAppendRows,void* _EifDeleteRows,void* _EifInsertCols,void* _EifAppendCols,void* _EifDeleteCols,void* _EifSetRowLabelValue,void* _EifSetColLabelValue,void* _EifGetRowLabelValue,void* _EifGetColLabelValue) { return (void*)new ELJGridTable (self,

3 6

[haskell.org Google Summer of Code] Call for Mentors
by Edward Kmett 07 Apr '15

07 Apr '15

We have had a rather large pool of potential students apply for this year's Google Summer of Code, but, ultimately, Google won't let us ask for a slot unless we have a potential mentor assigned in advance. On top of that, one thing we try to do with each project is wherever possible, assign both a primary and a backup mentor, so the available mentoring pool is drawn a little thin. Many hands make for light work, though: If you've mentored or thought about mentoring in years past, I'd encourage you to sign up on google-melange for the Google Summer of Code at: https://www.google-melange.com/gsoc/homepage/google/gsoc2015 and request a connection to haskell.org as a Mentor. Once you've done this you can help us vote on proposals, and should something seem appropriate to you, you can flag yourself as available as a potential mentor or backup mentor for one (or more) of the projects. We have a couple of weeks left to rate proposals and request slots, but it'd be good to make as much progress as we can this week. If you have any questions, feel free to reach out to me, or to Shachaf Ben-Kiki or Gershom Bazerman who have been helping out with organizational issues this year. We also have a #haskell-gsoc channel on irc.freenode.net if you have questions about what is involved. Thank you for your time and consideration, -Edward Kmett

1 0

Call for Haskell.org committee self-nominations
by Gershom B 06 Apr '15

06 Apr '15

Dear Haskellers, We have been overdue for some time in calling for a new round of nominations to the Haskell.org Committee. We have three members due for retirement -- Jason Dagit, Edward Kmett, and Brent Yorgey. The committee would like to thank them for their excellent service. To nominate yourself, please send an email to committee at haskell.org by 21 April 2015. The retiring members are eligible to re-nominate themselves. Please feel free to include any information about yourself that you think will help us to make a decision. Being a member of the committee does not necessarily require a significant amount of time, but committee members should aim to be responsive during discussions when the committee is called upon to make a decision. Strong leadership, communication, and judgement are very important characteristics for committee members. The role is about setting policy, providing direction/guidance for Haskell.org infrastructure, planning for the long term, and being fiscally responsible with the Haskell.org funds (and donations). As overseers for policy regarding the open source side of Haskell, committee members must also be able to set aside personal or business related bias and make decisions with the good of the open source Haskell community in mind. More details about the committee's roles and responsibilities are on *https://wiki.haskell.org/Haskell.org_committee <https://wiki.haskell.org/Haskell.org_committee>* If you have any questions about the process, please feel free to e-mail us at committee at haskell.org or to contact one of us individually. Regards, Gershom

1 0

How to implement a source-sink pattern
by Roland Lutz 06 Apr '15

06 Apr '15

Hi! I'm trying to implement a source-sink type of pattern where there are a number of sinks, each connected to exactly one source, and a number of sources, each connected to zero or more sinks. The program consists of some modules, each defining their own sources and sinks. To illustrate this, here's what this would look like in C: /* global.h */ struct source { char *state; /* some more fields */ } struct sink { struct source *source; char *state; /* some more fields */ } struct sink **get_sinks_for_source(struct source *source); /* module_a.c */ struct source a_source, another_source; struct sink foo, bar, baz; ... foo.source = &a_source; ... Since getting the list of sinks for a source is a common operation, I'd probably define some kind of reverse map which is updated when a sink is remapped to a new source. I tried to rebuild this in Haskell, but the result is ridiculously complicated. Since I can't use pointers, I had to define an ordinal type class to enumerate the sources and sinks and use this to look up the actual data from the world state. But then I couldn't define the Sink type properly as I can't do: data SinkInfo = Source a => SinkInfo { sinkSource :: a, sinkState :: String } I have to add the source type as a type attribute, leading to a world state with as many parameters as there are sinks. Also, I couldn't figure out how to implement a function like sinksForSource :: Source a => WorldState p q r -> a -> [Sink b => b] since the source types won't match the type of the lookup key, and the sinks can be from different modules. Now here is the actual code (comments indicate where I intend to split it into individual files): {- Global.hs -} data SourceInfo = SourceInfo { sourceState :: String } class Eq a => Source a where getSourceInfo :: WorldState p q r -> a -> SourceInfo data SinkInfo a = SinkInfo { sinkSource :: a, sinkState :: String } class Sink a where getSinkInfo :: Source x => WorldState x x x -> a -> SinkInfo x -- should allow different arguments to WorldState {- ModuleA.hs -} data ModuleASource = ASource | AnotherSource deriving (Eq) instance Source ModuleASource where getSourceInfo world ASource = aSource $ moduleAState world getSourceInfo world AnotherSource = anotherSource $ moduleAState world data ModuleASink = Foo | Bar | Baz instance Sink ModuleASink where getSinkInfo world Foo = foo $ moduleAState world getSinkInfo world Bar = bar $ moduleAState world getSinkInfo world Baz = baz $ moduleAState world data ModuleAState p q r = ModuleAState { aSource :: SourceInfo, anotherSource :: SourceInfo, foo :: SinkInfo p, bar :: SinkInfo q, baz :: SinkInfo r } sinksForSourceInModuleA :: Source x => ModuleAState x x x -> x -> [ModuleASink] -- should allow different arguments to ModuleAState and return Sink b => [b] sinksForSourceInModuleA (ModuleAState _ _ foo bar baz) source = (if sinkSource foo == source then [Foo] else []) ++ (if sinkSource bar == source then [Bar] else []) ++ (if sinkSource baz == source then [Baz] else []) {- Main.hs -} data WorldState p q r = WorldState { moduleAState :: ModuleAState p q r } initState :: WorldState ModuleASource ModuleASource ModuleASource initState = WorldState $ ModuleAState (SourceInfo "a source init state") (SourceInfo "another source init state") (SinkInfo ASource "foo init state") (SinkInfo ASource "bar init state") (SinkInfo AnotherSource "baz init state") remapBar :: WorldState p q r -> WorldState p ModuleASource r remapBar (WorldState a) = WorldState $ a { bar = SinkInfo AnotherSource (sinkState $ bar a) } sinksForSource :: Source x => WorldState x x x -> x -> [ModuleASink] -- should allow different arguments to ModuleAState and return Sink b => [b] sinksForSource (WorldState a) source = sinksForSourceInModuleA a source main :: IO () main = let before = initState after = remapBar before in do putStrLn $ "Number of sinks for another source before: " ++ (show $ length $ sinksForSource before AnotherSource) putStrLn $ "Number of sinks for another source after: " ++ (show $ length $ sinksForSource after AnotherSource) There are some problems with this code: * I couldn't figure out how to resolve the circular references which are created by splitting this into individual files. * Source and sink ordinals can't be mixed between modules, so I wouldn't be able to add a module B anyway. * Looking up the source/sink states by ordinal keys is kind of cumbersome but works. * To get the list of sinks connected to a given source, the whole world state has to be polled. I expect this to be grossly inefficient (unless Haskell does some magic here) but I'm not sure how to add a cache in a consistent way. I can't believe this should be so complicated in Haskell, so I guess I'm trying to do this in an un-Haskell-ish way, or maybe there's something obvious I haven't seen. I'd be happy about any suggestions. Roland

3 4

Initializing dynamic libraries
by Henk-Jan van Tuyl 06 Apr '15

06 Apr '15

L.S., I am using C++ dynamic libraries via a dynamic library written in C. The first thing my Haskell software does, is calling a C function to initiate the C++ libraries; but the C++ libraries generate warnings about not being able to set certain things, before the Haskell program initializes everything. Is there some automatic call to the dynamic libraries done, before execution of the main function in the Haskell program? Regards, Henk-Jan van Tuyl -- Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

2 1

Functional dependencies conflict
by Daniel Trstenjak 05 Apr '15

05 Apr '15

Hi, I'm getting the compile error: Gamgine/Image/PNG/Internal/Parser.hs:14:10: Functional dependencies conflict between instance declarations: instance Monad m => Stream LB.ByteString m Word8 -- Defined at Gamgine/Image/PNG/Internal/Parser.hs:14:10 instance Monad m => Stream LB.ByteString m Char -- Defined in ‘Text.Parsec.Prim’ The relevant stuff from the parsec 3.1.9 code[1] is: {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleContexts, UndecidableInstances #-} ... import qualified Data.ByteString.Lazy.Char8 as CL import qualified Data.ByteString.Char8 as C ... class (Monad m) => Stream s m t | s -> t where uncons :: s -> m (Maybe (t,s)) instance (Monad m) => Stream CL.ByteString m Char where uncons = return . CL.uncons instance (Monad m) => Stream C.ByteString m Char where uncons = return . C.uncons And from my code[2] is: {-# LANGUAGE BangPatterns, FlexibleInstances, MultiParamTypeClasses, FlexibleContexts #-} ... import qualified Data.ByteString.Lazy as LB ... instance (Monad m) => Stream LB.ByteString m Word8 where uncons = return . LB.uncons As you can see, the instances are for different ByteString types, therefore I don't quite get where GHC sees here any conflicts. Greetings, Daniel [1] https://github.com/aslatter/parsec/blob/master/Text/Parsec/Prim.hs [2] https://github.com/dan-t/Gamgine/blob/master/Gamgine/Image/PNG/Internal/Par…

3 5

Generalizing "unlift" functions with monad-control
by Michael Snoyman 05 Apr '15

05 Apr '15

I'm trying to extract an "unlift" function from monad-control, which would allow stripping off a layer of a transformer stack in some cases. It's easy to see that this works well for ReaderT, e.g.: {-# LANGUAGE RankNTypes #-} {-# LANGUAGE TypeFamilies #-} import Control.Monad.Trans.Control import Control.Monad.Trans.Reader newtype Unlift t = Unlift { unlift :: forall n b. Monad n => t n b -> n b } askRun :: Monad m => ReaderT r m (Unlift (ReaderT r)) askRun = liftWith (return . Unlift) The reason this works is that the `StT` associated type for `ReaderT` just returns the original type, i.e. `type instance StT (ReaderT r) m a = a`. In theory, we should be able to generalize `askRun` to any transformer for which that applies. However, I can't figure out any way to express that generalized type signature in a way that GHC accepts it. It seems like the following should do the trick: askRunG :: ( MonadTransControl t , Monad m , b ~ StT t b ) => t m (Unlift t) askRunG = liftWith (return . Unlift) However, I get the following error message when trying this: foo.hs:11:12: Occurs check: cannot construct the infinite type: b0 ~ StT t b0 The type variable ‘b0’ is ambiguous In the ambiguity check for the type signature for ‘askRunG’: askRunG :: forall (t :: (* -> *) -> * -> *) (m :: * -> *) b. (MonadTransControl t, Monad m, b ~ StT t b) => t m (Unlift t) To defer the ambiguity check to use sites, enable AllowAmbiguousTypes In the type signature for ‘askRunG’: askRunG :: (MonadTransControl t, Monad m, b ~ StT t b) => t m (Unlift t) Adding AllowAmbiguousTypes to the mix provides: foo.hs:17:30: Could not deduce (b1 ~ StT t b1) from the context (MonadTransControl t, Monad m, b ~ StT t b) bound by the type signature for askRunG :: (MonadTransControl t, Monad m, b ~ StT t b) => t m (Unlift t) at foo.hs:(12,12)-(16,25) ‘b1’ is a rigid type variable bound by the type forall (n1 :: * -> *) b2. Monad n1 => t n1 b2 -> n1 (StT t b2) at foo.hs:1:1 Expected type: Run t -> Unlift t Actual type: (forall (n :: * -> *) b. Monad n => t n b -> n b) -> Unlift t Relevant bindings include askRunG :: t m (Unlift t) (bound at foo.hs:17:1) In the second argument of ‘(.)’, namely ‘Unlift’ In the first argument of ‘liftWith’, namely ‘(return . Unlift)’ I've tested with both GHC 7.8.4 and 7.10.1. Any suggestions?

3 7

Is it possible for cabal sandboxes to use $HOME/.cabal/lib?
by Aldo Davide 05 Apr '15

05 Apr '15

Hi all, There are some packages that I use again and again and I would like to install them once (but not in a system-wide location) and then have cabal sandboxes use that install, instead of installing them in every sandbox, which is time consuming. Is there a way do that? For example, I noticed that cabal, when operating inside a sandbox, can still find the packages installed system-wide, but not the ones in $HOME/.cabal/lib. Can I change that? Thanks

5 8

Help wanted: working on the GHC webpage
by Austin Seipp 03 Apr '15

03 Apr '15

Hello *, For a while now, I've been wanting to do a facelift on the GHC homepage, but among many other things it's been a low priority. I'd like for people to help, so I've tried to get the ball rolling. The webpages existed in a Darcs repository previously (which wasn't available online), but earlier today I converted them to a git repository which you can find here: https://github.com/haskell-infra/ghc-homepage The site is currently composed of a set of "server side include" files that have a crude form of HTML templating. So it's mostly just pretty verbose to add or refactor anything, and the sites templating and styling is quite old (it dates back at least 10 years!) So, I'm making an official call for some help. At the very least, I'd like to at least end up converting the site to something like Hakyll which is doable without me causing a lot of damage to the stylesheets, but for the actual page itself I'd really appreciate it if anyone could help out! Please send pull requests or file issues, it's much appreciated. -- Regards, Austin Seipp, Haskell Consultant Well-Typed LLP, http://www.well-typed.com/

2 1

Re: [Haskell-cafe] An Easy Solution to PVP Bounds and Cabal Hell
by Olaf Klinke 02 Apr '15

02 Apr '15

I am mostly a consumer of Haskell and have not worked much with the interior of cabal or GHC, but Thomas Tuegel correctly pointed out that with version numbers a package can never safely depend on another package version that was released after itself. The empirical approach of trying builds is probably the most inclusive one. But let us think why dependencies can break a package. It is because a function was removed from the namespace, conflicting things have been added to the namespace, a data type definition has changed or the modules have been re-structured. In the worst case, none of the above has happened but the semantics of a function has changed without affecting its type. But all other cases can be dealt with: When importing a module, either a smart compiler figures out or the programmer states explicitly which imported functions are expected to be provided by the imported module and what type they have. Thus, the version number of a package is replaced by the collection of classes, types and type signatures its modules export. After all, the version number can be seen as a crude „hash“ of this information. For example, instead of stating import Data.List (mapAccumL) on would say import Data.List (mapAccumL :: (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])) or rather the compiler would fill in this information and save it together with the package as a dependency. Now when a new version of Data.List comes out, it can be automatically checked whether all functions _used_ by the importing module are still exported and have the same type signature. Modulo semantics, this should be a pretty good estimate of whether a build will fail or succeed. One could possibly even add QuickCheck properties to the signatures stating that the imported functions are expected to behave in a certain way in the importing module. When installing the new package on a system, all these assertions need to be checked. Isn’t that what configure scripts do prior to executing a makefile? Olaf

1 0

Haskell-programming sysadmin opportunity at SFLC
by Clint Adams 02 Apr '15

02 Apr '15

The Software Freedom Law Center is seeking a motivated systems administrator for our small office, where we use only free and open source software. The Systems Administrator will be responsible for three main areas of work: systems maintenance, user support, and systems development. Our existing systems are a collection of Debian servers that provide central services to the office. In addition to Debian, we use: - Apache - Asterisk - Ceph - deets - dirvish and BoxBackup - Ganeti with Xen and KVM - Gitolite - Hakyll - hledger and hledger-web - Ikiwiki - Monkeysphere - Nginx - OpenLDAP - OpenVPN - Postfix/SpamAssassin/Dovecot - Radicale - Yesod as well as a number of other systems. Ideal candidates will have experience with most of these components and the ability to quickly master the ones they know less about. As our new Systems Administrator, you will be responsible for maintaining and rebuilding our servers as necessary so some knowledge of server components and hardware configuration will be needed. You should have experience with firewall management and secure network design. Experience with low-latency bandwidth shaping preferred. Programming experience with Perl, Python, Haskell, and shell scripts will also be necessary for maintaining legacy systems. In addition to the servers, you will also be responsible for supporting 5—10 desktop users with their daily use of free software. Additional help with this activity is available around the office and many users are self-supporting for local system issues. All office user machines are running Debian. You will be frequently tasked with other functions, which may include code analysis, explaining technological concepts and licensing to lawyers, community outreach, and anything else which may require technical expertise. We intend to continue to improve our free software technology for running our law practice. There are many challenging projects we’d like to do and about which we hope you will be excited. Experience working with software development in addition to systems administration is therefore a big plus. Position includes full benefits. Please submit a cover letter and resume in a free document format to officemanager(a)softwarefreedom.org Applications should be submitted no later than April 15, 2015

1 0

cabal haddock --executables
by Maurizio Vitale 02 Apr '15

02 Apr '15

I'm getting: cabal: internal error when calculating transitive package dependencies. Debug info: [] and it seems this has been a problem for quite some while (and it has to do with the executable depending on a local library) is there any known workaround? Thanks, Maurizio

2 2

Announcing: LTS (Long Term Support) Haskell 2
by Michael Snoyman 02 Apr '15

02 Apr '15

The LTS Haskell 2.0 release is officially out the door. More details are available at: https://www.fpcomplete.com/blog/2015/04/announcing-lts-2 For the tl;dr crowd, run the following inside your project to get a cabal.config with appropriate constraints: wget https://www.stackage.org/lts/cabal.config There are some questions about policy at the end of the post that I'd appreciate feedback on.

1 0

Parallel Profiling
by Dominic Steinitz 02 Apr '15

02 Apr '15

Does anyone know of any tools for analysing parallel program performance? I am trying to use threadscope but it keeps crashing with my 100M log file and ghc-events-analyze is not going to help as I have many hundreds of threads all carrying out the same computation. I think I’d like a library that would allow me to construct my own analyses rather than display them via GTK. There is ghc-events but that seems to be just for parsing the logs and I couldn’t find anything that used it in the way I would like to (apart from threadscope and ghc-events-analyze of course). Thanks Dominic Steinitz dominic(a)steinitz.org http://idontgetoutmuch.wordpress.com

2 2

Haskell Weekly News
by Kim-Ee Yeoh 01 Apr '15

01 Apr '15

*Top picks:* - Bot attack on Trac <https://mail.haskell.org/pipermail/ghc-devs/2015-March/008557.html> pummels GHC HQ productivity! Do you know a thing or two about hardening web apps? Can you help? - A month ago <http://haskell.1045720.n5.nabble.com/Haskell-Weekly-News-td5766529.html> you read about the absence of a correct operational spec for Core. Christiaan Baaij <http://ghc.haskell.org/trac/ghc/ticket/10121#comment:7> proffers rewriting rules for something "very much like Core" from his 2014 thesis on Digital Circuits in CλaSH, a tool designed for Computer Architecture for Embedded Systems (CAES). The consensus is that they probably also work for GHC Core. - Neil Mitchell reports Unable to load package Win32-2.3.1.0 <https://ghc.haskell.org/trac/ghc/ticket/10165>. The problem? SetWindowLongPtrW exists only on 64-bit. The haskell win32 shim wasn't switching to SetWindowLongW on 32-bit. Darren Grant steps up to offer a fix, which Austin Seipp promptly checks in. - Ki Yung Ahn <http://haskell.1045720.n5.nabble.com/Do-we-have-idiom-for-lifting-a-state-m…> asks for a "wrapper that lifts actions of (State s1 a) to (State (s1,s2) a). " The answer? A function called "zoom" in lens libraries. - Chris Done <https://groups.google.com/forum/#!msg/commercialhaskell/lRTDiTLIKi0/Kw0UGwa…> has started the ball rolling on GPG-based package signing. So far, Michael Snoyman and Neil Mitchell have had their keys signed by Chris. He invites others to join the party. - Levant Erkok <https://ghc.haskell.org/trac/ghc/ticket/10215> joins Lennart Augustsson <https://ghc.haskell.org/trac/ghc/ticket/9238> in hitting a bug with signed zeros <http://en.wikipedia.org/wiki/Signed_zero>. The function isNegativeZero breaks under optimizations. - James Stevenson <https://blog.safaribooksonline.com/2015/03/30/high-performance-log-parsing-…> over at Safari Books Online reveals how they use Haskell to parse web logs more efficiently than Python. The top comment <https://news.ycombinator.com/item?id=9294036> at Hacker News observes the absence of a proper benchmark pitting Python vs Haskell. James responds that they did an informal comparison that showed "the number of lines parsed/second [with Python] was far smaller than the attoparsec-based parser." Elsewhere, Luke Randall <http://www.reddit.com/r/haskell/comments/30xugp/highperformance_log_parsing…> submits the link on reddit and thinks it's a "very gentle intro to parsing using attoparsec". - Ian Ross <http://www.skybluetrades.net/blog/posts/2015/03/30/c2hs-snowmelt.html> announces a new C2HS release christened "Snowmelt". Originally authored by Manuel Chakravarty, C2HS eases the pain of manually creating FFI shims for C libraries. The latest release, thanks to work contributed by Philipp Balzarek, achieves better cross-language alignment of C enum and Haskell Enum types, among other improvements. Reddit discussion here. <http://www.reddit.com/r/haskell/comments/30u8pk/new_c2hs_release_0251_snowm…> - Michael Snoyman <https://www.fpcomplete.com/blog/2015/03/announce-ide-backend> announces FPComplete's open sourcing of their IDE backend, comprising a wrapper around the GHC API. - Jon Sterling at PivotCloud <https://ghc.haskell.org/trac/ghc/ticket/9539#comment:2> hits an STM TQueue bug initially reported by John Lato seven months ago. A sufficiently fast writer can cause the reader to never get scheduled, which leads to live-lock in Jon's production code. The fix looks to be as simple as lazifying a case into a let in readTQueue. Curiously, the code uses let in Simon Marlow's book on Haskell concurrency <http://chimera.labs.oreilly.com/books/1230000000929/ch10.html#CO37-2> but not in the STM package you have on your machine. *Tweets of the week:* - Michael Neale <https://twitter.com/michaelneale/status/567532684595851264>: Haskell Quickcheck enters a bar, asks for 1 beer, 42 beers, -Inifinity beers, shaves bartenders beard, sets off a tactical nuke. - Dierk König <https://twitter.com/mittie/status/582803534950862848>: #Haskell is the gold standard for programming languages and #Frege makes it available on the #JVM -- Kim-Ee

1 0

An Easy Solution to PVP Bounds and Cabal Hell
by Gershom B 01 Apr '15

01 Apr '15

Recently there has been some discussion about how we can fix the problem of “Cabal Hell”. Some people advocate restrictive upper bounds, to prevent packages from being broken by new updates. Some other people point out that too-restrictive bounds can lead to bad install plans, since some packages might want newer versions of some dependencies, and others older versions. Still other people say that we can _retroactively_ fix upper bounds (in either direction) by modifying cabal files using the new features in Hackage. Some people think this is a terrible idea because it looks like we are mutating things, and this confuses hashes. In turn, these people support either nix or a nix-like approach by which packages have hashes that encompass the full versions of all their transitive dependencies. With that in hand, we can cache builds and mix-and-match to build the precise environment we want for each package while reducing redundant computation. However, the cache of all the various binary combinations may still grow large! And none of this fully begins to address the dreaded “diamond dependency” problem. Here is a chart of some such solutions: http://www.well-typed.com/blog/aux/images/cabal-hell/cabal-hell-solutions.p… One way to look at a particular build is in an n-dimensional state space (of the Hilbert sort) determined by all its dependencies, not least the compiler itself. The solver acts as a particle traversing this space. But this description is too simple. Our state of dependencies and constraints itself varies and grows over time. So another approach is to think of the dependencies as a transitive graph, where each node may vary along a time axis, and as they slide along the axis, this in turn affects their children. We now have not just one Hilbert space, but a collection of them related by branching trees as authors locally modify the dependencies of their packages. If we keep this simple model in mind, it is easy to see why everyone is always having these debates. Some people want to fix the graph, and others want to simplify it. Some people want an immutable store, and some people want to rebase. But we can’t “really” rebase in our current model. Bearing in mind our model of a space-time continuum of hackage dependences, the solution emerges — enforce immutability, but allow retroactive mutation. For instance, suppose Fred tries to install package Foo on Friday evening, but discovers that it depends on version 1.0 of Bar (released the previous Friday) that in turn depends on version 0.5 of Baz but Foo also depends on version 0.8 of Baz. So Fred branches Bar and changes the dependency, which in turn informs Betty, that there is also a 1.0 of Bar with different dependencies and we have forked our package timeline. On getting this message on Monday, Betty can merge by pushing with --force-rewrites and this goes back in the timeline and makes it so that Baz retroactively had the right dependencies and now Fred, as of the previous Friday, no longer has this problem. (That way he still has the weekend). Now the failed build is cut off temporarily into a cycle in the package timeline that is disconnected from the rewrite. We stash it with “hackage stash” until Monday at which time the dependency graph is 100 percent equalized and primed for new patches. At this point we unstash Foo as of Friday and it is replaced by the Foo from the new timeline. Friday Fred needs to remain stashed lest he run into himself. The longer he can be avoided by his Monday self the better. Future work could include bots which automate pruning of artifacts from redundant branches. If this description was too abrupt, here is a diagram with a fuller description of the workflow: http://bit.ly/15IIGac I know there are some new ideas to take in here, and there is a little technical work necessary to make it feasible, but in my opinion if you can understand the current cabal situation, and you can understand how git and darcs work, then you should be able to understand this too. Hopefully by this time next year, we’ll be able to say that our problems with cabal have been truly wiped from our collective memory. HTH, HAND. Gershom

4 3

ANNOUNCE: Parsed 0.0.1
by Mike Izbicki 01 Apr '15

01 Apr '15

I'm pleased to announce the first release of the Parsed library (pronounced par-séd). Parsed is a reimplementation of Haskell's excellent Parsec library in the Unix shell. In particular, the Unix pipe operator | corresponds exactly to Haskell's Applicative bind *>. Here's a quick example to get a feel for the syntax. The following bash one liner creates a parser for matching balanced parenthesis: ``` parens() { choice "$1" "match '(' | parens \"$1\" | match ')'"; } ``` For more detailed examples and implementation notes, please see the Parsed paper accepted at SIGBOVIK2015: https://github.com/mikeizbicki/parsed/raw/master/sigbovik2015/paper.pdf You can download Parsed from its github page at: https://github.com/mikeizbicki/parsed

3 4

Specify OS version
by Sergey Bushnyak 01 Apr '15

01 Apr '15

Hi Cafe! I have program written in Haskell and Swift that runs on Mac. This program uses some features that was introduced in last version of OS X “Yosemite” 10.10, but some of my users use previous version "Maverics " 10.9. Is there some technique that allows me to extend my cabal file and specify which *version* of os is currently in use and don't load some of modules? AFAIK, Cabal's `conditional` doesn't provide such mechanism, but something like ``` if os(osx) && ver(=10.10) if os(osx) && ver(<=10.9) ``` will be nice. Maybe there is other approach to this problem?I don't want to use `CPP` extension to handle this within code. Thanks -- Best regards, Sergey Bushnyak

2 2

Speed up ghc -O2
by Kees Bleijenberg 01 Apr '15

01 Apr '15

My program reads a xls file and creates a haskell program that does exactly the same as what the xls does. Every cell in the xls is a function and contains 2 lines: the type declaration and 1 line the implementation. The type of a cell is XlsCell. data XlsCell = Reader ExternalCells XlsCellRes data XlsCellRes = XlsCellString String | XlsCellBool Bool | ..... type ExternalCells = Map String XlsCellRes -- search (or set) a value of a cell by its name. The externalCells are for the cells you can change at runtime. The generated program was first 30000 lines. When I compiled it with ghc 7.8.3. -O0 the program worked, but was terribly slow. With -O2 I got: out of memory. With a few trics the generated code is now split up in 2 files 5000 and 10000 lines. I've upgraded to ghc 7.8.4. If I do ghc -O2 the program takes more then 4 hours to compile. The -O2 compilation is essential. The resulting program is much (more then 10x) faster then without -O2. What can I do (changes in the generated code, changes to speed up ghc?) to make ghc faster with -O2? I tried ghc-make, but it doesn't make a big difference. Kees

1 0

Journal of Functional Programming - Call for PhD Abstracts
by Graham Hutton 01 Apr '15

01 Apr '15

============================================================ CALL FOR PHD ABSTRACTS Journal of Functional Programming Deadline: 30th April 2015 http://tinyurl.com/jfp-phd-abstracts ============================================================ PREAMBLE: Many students complete PhDs in functional programming each year, but there is currently no common location in which to promote and advertise the resulting work. The Journal of Functional Programming would like to change that! As a service to the community, JFP recently launched a new feature, in the form of a regular publication of abstracts from PhD dissertations that were completed during the previous year. The abstracts are made freely available on the JFP website, i.e. not behind any paywall, and do not require any transfer for copyright, merely a license from the author. Please submit dissertation abstracts according to the instructions below. A dissertation is eligible if parts of it have or could have appeared in JFP, that is, if it is in the general area of functional programming. JFP will not have these abstracts reviewed. We welcome submissions from both the PhD student and PhD advisor/ supervisor although we encourage them to coordinate. ============================================================ SUBMISSION: Please submit the following information to Graham Hutton <graham.hutton(a)nottingham.ac.uk> by 30th April 2015. o Dissertation title: (including any subtitle) o Student: (full name) o Awarding institution: (full name and country) o Date of PhD award: (month and year; depending on the institution, this may be the date of the viva, corrections being approved, graduation ceremony, or otherwise) o Advisor/supervisor: (full names) o Dissertation URL: (please provide a permanently accessible link to the dissertation if you have one, such as to an institutional repository or other public archive; links to personal web pages should be considered a last resort) o Dissertation abstract: (plain text, maximum 1000 words; you may use \emph{...} for emphasis, but we prefer no other markup or formatting in the abstract, but do get in touch if this causes significant problems) Please do not submit a copy of the dissertation itself, as this is not required. JFP reserves the right to decline to publish abstracts that are not deemed appropriate. ============================================================ PHD ABSTRACT EDITOR: Graham Hutton School of Computer Science University of Nottingham Nottingham NG8 1BB United Kingdom ============================================================ This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please send it back to me, and immediately delete it. Please do not use, copy or disclose the information contained in this message or in any attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. This message has been checked for viruses but the contents of an attachment may still contain software viruses which could damage your computer system, you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

1 0

Enforcing data structures invariant in the type system
by Nicola Gigante 31 Mar '15

31 Mar '15

Hi all. I’m very interested in what can be done with Haskell’s type system regarding the enforcing of algorithms and data structures invariants. For example, I remember I saw a paper about an implementation of a red-black tree in Haskell where the types guaranteed the invariant about the alternation of rad and black nodes. I would like to learn those techniques, in particular the use of language features that enable this kind of things and then how to do them in practice. In the past tried hacking something with GADTs and Data Kinds but I've always got stuck with GHC errors that I could not understand, so I think I’m missing something. Where could I start from? Are there simple walk-through examples and/or fundational material? For example is it possible to write a sorting function that guarantees in the types that the output is sorted? I don’t need this specific example but you got the point. Thank you very much, Nicola

5 9

Data.EnumMap ?
by Johannes Waldmann 31 Mar '15

31 Mar '15

Dear Cafe, in containers, we have Data.IntMap/IntSet . Because of the underlying implementation (patricia trees), keys/elements indeed have to be Int (we need their bits). This is a conflict with type-safety: I try to avoid Int, and use some newtype T = T Int instead. E.g., I want to distinguish several different indices for the same structure, like row and column numbers in (sparse) matrices, or vertices in bipartite graphs. So, I made these trivial wrappers EnumMap and EnumSet: https://github.com/jwaldmann/satchmo-solver/tree/master/src/Data Is this reasonable (do from/toEnum really have zero cost)? Would this be a useful addition to containers? - J.W.

4 5

Hackage trustee proposal: Curating the Hackage package collection
by Adam Bergmark 31 Mar '15

31 Mar '15

Dear Haskell Community, For some time Hackage has contained a user group called "Trustees", http://hackage.haskell.org/packages/trustees/ . Description: The role of trustees is to help to curate the whole package collection. Trustees have a limited ability to edit package information, for the entire package database (as opposed to package maintainers who have full control over individual packages). Trustees can edit .cabal files, edit other package metadata and upload documentation but they cannot upload new package versions." In short, making sure that packages keep building and filling the gap between unreachable maintainers and package take-overs. Up until now we have been very careful with changes since we haven't had a defined process. Spurred by SPJ and others we have been working on a proposal for how we should operate. You can find the proposal here: https://gist.github.com/bergmark/76cafefb300546e9b90e We would now like your feedback! Some specific things from the proposal that we'd like your opinion on: * Section 1: No opt-out for restricting bounds * Section 2: Opt-out rather than opt-in procedure for loosening version constraints * Section 2: Do you care whether you are notified before or after a version constraint is loosened? * Section 3: The time frame for publishing simple source changes * Section 3: What exactly should constitute a "simple source change" We also have a github repository where YOU can file issues about broken packages, you can start doing this right now! https://github.com/haskell-infra/hackage-trustees/ Please share this with as many people as possible. We are looking forward to hear your thoughts! Sincerely, Adam Bergmark

6 8

Opt-in upper-bounds notification service?
by Joachim Breitner 31 Mar '15

31 Mar '15

Hi, I don’t always have a complete oversight of what our ecosystem provides... do we already have a way to (opt-in) get a mail when a dependency of one of my packages was uploaded in a version that is beyond the upper-bound specified by my packages? Currently I get pinged by Michael Snoyberg when that happens, e.g. in https://github.com/fpco/stackage/issues/514, but that’s always a short while after the problem, and I’d like to fix this before anyone manually notices. If someone would hack up such as service, I’d be happy to use it. Greetings, Joachim -- Joachim “nomeata” Breitner mail(a)joachim-breitner.de • http://www.joachim-breitner.de/ Jabber: nomeata(a)joachim-breitner.de • GPG-Key: 0xF0FBF51F Debian Developer: nomeata(a)debian.org

3 4

Template haskell and the dependencies of the generated executable
by Aldo Davide 31 Mar '15

31 Mar '15

When I use template haskell to generate some code at compile time and splice it in my program, the generated executable still depends on template haskell (in case of -dynamic), or the Template haskell library is included in my executable (in the case of -static). Isn't that unnecessary? For example. Suppose that I use the almost trivial raw-strings-qq package to implement a hello world program: {-# LANGUAGE QuasiQuotes #-} import Text.RawString.QQ (r) main = putStrLn [r|Bonjour tout le monde|] Then the r quasi quoter runs at compile time and generates a string literal. So basically, the program that gets compiled is the following: main = putStrLn "Bonjour tout le monde" Despite that template haskell is only used at compile time, the generated executable (compiled with the -dynamic flags) depends on the following libraries: libHSarray-0.5.0.0-ghc7.8.4.so libHScontainers-0.5.5.1-ghc7.8.4.so libHSdeepseq-1.3.0.2-ghc7.8.4.so libHSpretty-1.1.1.1-ghc7.8.4.so libHSraw-strings-qq-1.0.2-ghc7.8.4.so libHStemplate-haskell-2.9.0.0-ghc7.8.4.so in addition to the ones that the non template haskell version of the program depends. Shouldn't ghc avoid that?

1 0

Looking for Haskell contract work
by Alexander Berntsen 31 Mar '15

31 Mar '15

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Hallo Haskell friends, My company[0] uses Haskell for most of our work. Speaking of work, we are currently looking for some more of it. If anyone has some work (FSVO "work" that includes hacking, advising, teaching, etc.), please contact me off-list. Thanks! [0] plaimi: <https://secure.pe.plaimi.net>. - -- Alexander alexander(a)plaimi.net https://secure.plaimi.net/~alexander -----BEGIN PGP SIGNATURE----- Version: GnuPG v2 iF4EAREIAAYFAlUaphUACgkQRtClrXBQc7UySwD/digSIVDgS25tRW4zUtfoO/E3 /vWOMwMRnn9nfFcirrAA/0fFsl8WogNG/J2AP188517xcV4zLV1up7YtUsbEWRnh =JbNc -----END PGP SIGNATURE-----

1 1

ANN: base-compat updated for AMP + request for collaboration
by Simon Hengel 31 Mar '15

31 Mar '15

Hi, I updated base-compat[1] for the recent AMP/Foldable/Traversable changes and base-4.8.0.0. A new version 0.6.0 is on Hackage. The purpose of base-compat is to provide a way to write code that works with multiple versions of GHC without the need for CPP. The idea is to have .Compat modules (e.g. Control.Exception.Compat) that provide the same interface across all supported versions of GHC (we test GHC 7.* on travis and I test 6.12.3 manually). The main focus of this release is to make Prelude.Compat as complete as possible to help with the AMP/Foldable/Traversable transition. Prelude.Compat now exposes the exact same interface as Prelude from base-4.8.0.0. It can be used together with -XNoImplicitPrelude to write code that works with all supported versions of GHC, e.g.: {-# LANGUAGE NoImplicitPrelude #-} import Prelude.Compat main :: IO () main = mapM_ print (Just 23) Prelude.Compat is complete and we have tests that ensure that the interface is the same for all supported versions of GHC. But other modules still need more work. In the past base-compat did not get the love it deserves, but I'm committed to put more effort into it and make it as complete as possible. Any help with that effort would be greatly appreciated. If you want to help, please open issues and pull requests on GitHub, or send me feedback by email or on IRC (solirc on Freenode). Cheers, Simon [1] http://hackage.haskell.org/package/base-compat

1 0

GHC update from 7.8.4 to 7.10.1 breaks 1, 500 packages in NixOS
by Peter Simons 31 Mar '15

31 Mar '15

Hi guys, the Nixpkgs distribution [1] contains all of Hackage -- 7,898 packages at the time of this writing --, and we regularly build these packages with GHC 7.8.4 in our CI environment [2] running NixOS Linux. About 3,000 of these builds are disabled outright, because we know they won't succeed anyway (i.e. they have dependencies we cannot fulfill), but the remaining 5,000 packages compile successfully most of the time. Now, a few days ago, we created a separate build job [2] that compiles the same package set with GHC 7.10.1, and the result is interesting: with the newer compiler, approximately 1,500 packages are broken compared to the state with 7.8.4. A detailed list of broken packages can be found at [4]. Keep in mind that those figures only approximate reality. For instance, we patch packages sometimes to make their builds succeed even though the pristine version would not, and so far much more effort has gone into fixing 7.8.4 builds than we spent on fixing 7.10.1 builds. Also, some packages may compile fine when you run "cabal install <foo>" on your workstation, but those builds may fail in the context of NixOS for whatever reason. If anyone were to repeat this experiment on Darwin, Windows, Ubuntu, or Red Hat, the results would be different from our numbers! Still, based on the information we have, it's probably fair to say that the GHC 7.10.1 update breaks approximately 30% of all Haskell builds that worked with 7.8.4. Best regards, Peter [1] https://github.com/nixos/nixpkgs [2] http://hydra.cryp.to/jobset/nixpkgs/haskell-updates [3] http://hydra.cryp.to/jobset/nixpkgs/haskell-updates-ghc7101 [4] http://hydra.cryp.to/eval/304489#tabs-still-fail

2 1

GHC 7.10.1 on OS X
by Yongqian Li 30 Mar '15

30 Mar '15

Does anyone know how to resolve this issue? When I do a "cabal build", I get error: unknown directive .macosx_version_min 10, 0 ^ <no location info>: Error running clang! you need clang installed to use theLLVM backend (or GHC tried to execute clang incorrectly) <no location info>: ghc: phase `Clang (Assembler)' failed (exitcode = 1) However, my clang is fine, as is my LLVM: % clang --version Apple LLVM version 6.0 (clang-600.0.57) (based on LLVM 3.5svn) Target: x86_64-apple-darwin14.1.0 Thread model: posix % opt --version LLVM (http://llvm.org/) LLVM version 3.5.1 Optimized build with assertions. Built Jan 15 2015 (18:24:46). Default target: x86_64-apple-darwin14.1.0 Host CPU: core-avx2

2 1

linear: instance Additive (Point f) ??
by Richard Eisenberg 30 Mar '15

30 Mar '15

Hi café, I'm in the middle of responding to https://github.com/goldfirere/units/pull/45 and trying to learn the `linear` package, which I have yet to use. I have what may be a basic question: why is there an `instance Additive f => Additive (Point f)` (in the Affine module)? It would seem that the whole point of Point is that it is *not* Additive. We don't want to add Points! Could someone enlighten me? Thanks! Richard PS: Of course, this instance is directly hurting my use of the package. But it is hurting my understanding of the package, because it disagrees with the mental model I've built up of the definitions.

4 6

New Functional Programming Job Opportunities
by Functional Jobs 30 Mar '15

30 Mar '15

Here are some functional programming job opportunities that were posted recently: Full-stack Software Engineer at Capital Match http://functionaljobs.com/jobs/8802-full-stack-software-engineer-at-capital… Cheers, Sean Murphy FunctionalJobs.com

1 0

preprocessing and Parsec
by Maurizio Vitale 30 Mar '15

30 Mar '15

G'day, I'm implementing a parser for a language that has a preprocessor. It has `include, `ifdef..`else..`endif, `define and uses of the `defined fragments, which are also prefixed by '`'. I can think of two ways of doing this: a preprocess :: Stream->Stream (for String, Text, ByteString) or processing preprocessor directives as part of the"whitespace skipping" at begin of file and after each token. The first one seems cleaner/easier (and also allow parsers not to require a (restricted) IO monad for reading files). The second one, seems to make easier to give nice error messages (in the separate preprocessor way, you can add something like #line to tell where inclusions came from, but you cannot easily do this for macro replacement). My eventual goal is to give clang-like error messages with macro expansion backtrace. Any recommendations? pointers to examples of parsec-based parsers that have a pre-processing step? Thanks, Maurizio

1 0

Index for local documentation is incomplete
by Francesco Ariis 30 Mar '15

30 Mar '15

Dear Haskellers, I have a problem with local haddock documentation. Specifically, the documentation gets built but the index.html is not updated. As an example, here is the bottom part of the log of a package I installed a few days ago: > Haddock coverage: > 100% ( 6 / 6) in 'System.FilePath.Manip' > 100% ( 7 / 7) in 'System.FilePath.GlobPattern' > 100% ( 2 / 2) in 'System.FilePath.Glob' > 65% ( 41 / 63) in 'System.FilePath.Find' > Documentation created: dist/doc/html/filemanip/index.html > Creating package registration file: /tmp/pkgConf-filemanip-0.3.66815.3 > Installing library in > /home/user/.cabal/lib/i386-linux-ghc-7.8.3/filemanip-0.3.6.3 > Registering filemanip-0.3.6.3... The documentation files are present in ~/.cabal/share/doc/i386-linux-ghc-7.8.3/filemanip-0.3.6.3/html/index.html but when if I open `~/.cabal/share/doc/index.html`, there is no `System.FilePath.Find` module. cabal version is 1.22.0.0, GHC 7.8.3 Any idea on how to diagnose this?

1 1

Terra language: Lua+LLVM JIT+multi-stage metaprogramming
by oleg＠okmij.org 30 Mar '15

30 Mar '15

Bulat Ziganshin wrote: > It has predecessors like template haskell, metalua, julia, ocamlp4, > but all them lack either convenient multi-stage meta-programming, or > efficency of low-level code You have omitted MetaOCaml. One may argue about the convenience of MetaOCaml but one has to acknowledge that it is the typed and hygienic staged language. (The TExp subset of the new TH is typed and hygienic, but it does not permit any effects in the generator, which are often necessary). As to low level, it turns out relatively straightforward to interface MetaOCaml with LLVM, so that OCaml becomes a very powerful, typed and hygienic ``macro language'' for LLVM.

1 0

RFC: rewrite-with-location proposal
by Michael Snoyman 30 Mar '15

30 Mar '15

Quite a while back, Simon Hengel and I put together a proposal[1] for a new feature in GHC. The basic idea is pretty simple: provide a new pragma that could be used like so: error :: String -> a errorLoc :: IO Location -> String -> a {-# REWRITE_WITH_LOCATION error errorLoc #-} Then all usages of `error` would be converted into calls to `errorLoc` by the compiler, passing in the location information of where the call originated from. Our three intended use cases are: * Locations for failing test cases in a test framework * Locations for log messages * assert/error/undefined Note that the current behavior of the assert function[2] already includes this kind of approach, but it is a special case hard-coded into the compiler. This proposal essentially generalizes that behavior and makes it available for all functions, whether included with GHC or user-defined. The proposal spells out some details of this approach, and contrasts with other methods being used today for the same purpose, such as TH and CPP. Michael [1] https://github.com/sol/rewrite-with-location [2] http://hackage.haskell.org/packages/archive/base/4.6.0.1/doc/html/Control-E…

14 32

ANN: unification-fd 0.10.0
by wren romano 30 Mar '15

30 Mar '15

-------------------------------------------- -- unification-fd 0.10.0 -------------------------------------------- The unification-fd package offers generic functions for single-sorted first-order structural unification (think of programming in Prolog, or of the metavariables in type inference)[1][2]. The library *is* sufficient for implementing higher-rank type systems a la [Peyton Jones, Vytiniotis, Weirich, Shields], but bear in mind that unification variables are the metavariables of type inference--- not the type-variables. As of this version, the library is also sufficient for implementing (non-recursive) feature structure unification. An effort has been made to make the package as portable as possible. However, because it uses the ST monad and the mtl-2 package it can't be H98 nor H2010. However, it only uses the following common extensions which should be well supported[3]: Rank2Types MultiParamTypeClasses FunctionalDependencies -- Alas, necessary for type inference FlexibleContexts -- Necessary for practical use of MPTCs FlexibleInstances -- Necessary for practical use of MPTCs UndecidableInstances -- For Show instances due to two-level types -------------------------------------------- -- Changes since 0.8.0 (2012-07-11) -------------------------------------------- * (0.8.1) Added Functor, Foldable, and Traversable instances for COntrol.Unification.Types.UnificationFailure. Thanks Graham Rogers. * (0.9.0) Changed the fundeps on BindingMonad and RankedBindingMonad so that things compule under GHC 7.8.2 * (0.9.0) eta-expanded the rewrite rules in Data.Functor.Fixedpoint so that GHC 7.8 no longer gives warnings about not firing due to (.) possibly being inlined first * Cleaned things up to compile cleanly for GHC 7.10 * For EitherK and MaybeK, liberalized the instances to only require Applicative instead of Monad wherever possible. * Completely revamped the old UnificationFailure data type as the new UFailure data type and Fallible type class. This was necessary to clean up some deprecation warnings about using Control.Monad.Error, to remove the hack of needing an UnknownError constructor, and to make the data type for representing failures more extensible. -------------------------------------------- -- Description -------------------------------------------- The unification API is generic in the type of the structures being unified and in the implementation of unification variables, following the two-level types pearl of Sheard (2001). This style mixes well with Swierstra (2008), though an implementation of the latter is not included in this package. That is, all you have to do is define the functor whose fixed-point is the recursive type you're interested in: -- The non-recursive structure of terms data S a = ... -- The recursive term type type Term = Fix S And then provide an instance for Unifiable, where zipMatch performs one level of equality testing for terms and returns the one-level spine filled with pairs of subterms to be recursively checked, or Nothing if this level doesn't match. Each subterm can be separately marked as being resolved, Left xy, or as requiring further unification, Right(x,y). class (Traversable t) => Unifiable t where zipMatch :: t a -> t a -> Maybe (t (Either a (a, a))) The choice of which variable implementation to use is defined by similarly simple classes Variable and BindingMonad. We store the variable bindings in a monad, for obvious reasons. In case it's not obvious, see Dijkstra et al. (2008) for benchmarks demonstrating the cost of naively applying bindings eagerly. There are currently two implementations of variables provided: one based on STRefs, and another based on a state monad carrying an IntMap. The former has the benefit of O(1) access time, but the latter is plenty fast and has the benefit of supporting backtracking. Backtracking itself is provided by the logict package and is described in Kiselyov et al. (2005). In addition to this modularity, unification-fd implements a number of optimizations over the algorithm presented in Sheard (2001)--- which is also the algorithm presented in Cardelli (1987). * Their implementation uses path compression, which we retain. Though we modify the compression algorithm in order to make sharing observable. * In addition, we perform aggressive opportunistic observable sharing, a potentially novel method of introducing even more sharing than is provided by the monadic bindings. Basically, we make it so that we can use the observable sharing provided by the modified path compression as much as possible (without introducing any new variables). * And we remove the notoriously expensive occurs-check, replacing it with visited-sets (which detect cyclic terms more lazily and without the asymptotic overhead of the occurs-check). A variant of unification which retains the occurs-check is also provided, in case you really need to fail fast. * Finally, a highly experimental branch of the API performs *weighted* path compression, which is asymptotically optimal. Unfortunately, the current implementation is quite a bit uglier than the unweighted version, and I haven't had a chance to perform benchmarks to see how the constant factors compare. Hence moving it to an experimental branch. These optimizations pass a test suite for detecting obvious errors. If you find any bugs, do be sure to let me know. Also, if you happen to have a test suite or benchmark suite for unification on hand, I'd love to get a copy. -------------------------------------------- -- Notes and limitations -------------------------------------------- [1] At present the library does not appear amenable for implementing higher-rank unification itself; i.e., for higher-ranked metavariables, or higher-ranked logic programming. To be fully general we'd have to abstract over which structural positions are co/contravariant, whether the unification variables should be predicative or impredicative, as well as the isomorphisms of moving quantifiers around. It's on my todo list, but it's certainly non-trivial. If you have any suggestions, feel free to contact me. [2] At present it is only suitable for single-sorted (aka untyped) unification, a la Prolog. In the future I aim to support multi-sorted (aka typed) unification, however doing so is complicated by the fact that it can lead to the loss of MGUs; so it will likely be offered as an alternative to the single-sorted variant, similar to how the weighted path-compression is currently offered as an alternative. [3] With the exception of fundeps which are notoriously difficult to implement. However, they are supported by Hugs and GHC 6.6, so I don't feel bad about requiring them. Once the API stabilizes a bit more I plan to release a unification-tf package which uses type families instead, for those who feel type families are easier to implement or use. There have been a couple requests for unification-tf, so I've bumped it up on my todo list. -------------------------------------------- -- References -------------------------------------------- Luca Cardelli (1987) /Basic polymorphic typechecking/. Science of Computer Programming, 8(2):147--172. Atze Dijkstra, Arie Middelkoop, S. Doaitse Swierstra (2008) /Efficient Functional Unification and Substitution/, Technical Report UU-CS-2008-027, Utrecht University. <http://www.cs.uu.nl/research/techreps/repo/CS-2008/2008-027.pdf> Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, Mark Shields /Practical type inference for arbitrary-rank types/, to appear in the Journal of Functional Programming. (Draft of 31 July 2007.) Oleg Kiselyov, Chung-chieh Shan, Daniel P. Friedman, and Amr Sabry (2005) /Backtracking, Interleaving, and/ /Terminating Monad Transformers/, ICFP. <http://www.cs.rutgers.edu/~ccshan/logicprog/LogicT-icfp2005.pdf> Tim Sheard (2001) /Generic Unification via Two-Level Types/ /and Paramterized Modules/, Functional Pearl, ICFP. <http://web.cecs.pdx.edu/~sheard/papers/generic.ps> Tim Sheard & Emir Pasalic (2004) /Two-Level Types and/ /Parameterized Modules/. JFP 14(5): 547--587. This is an expanded version of Sheard (2001) with new examples. <http://web.cecs.pdx.edu/~sheard/papers/JfpPearl.ps> Wouter Swierstra (2008) /Data types a la carte/, Functional Pearl. JFP 18: 423--436. <http://www.cs.ru.nl/~wouters/Publications/DataTypesALaCarte.pdf> -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/unification-fd Darcs: http://community.haskell.org/~wren/unification-fd Haddock (Darcs version): http://community.haskell.org/~wren/unification-fd/dist/doc/html/unification… -- Live well, ~wren

1 0

ANN: stm-chans 3.0.0.3
by wren romano 30 Mar '15

30 Mar '15

-------------------------------------------- -- stm-chans 3.0.0.3 -------------------------------------------- The stm-chans package offers a collection of channel types, similar to Control.Concurrent.STM.{TChan,TQueue} but with additional features. -------------------------------------------- -- Changes since 3.0.0 (2013-05-29) -------------------------------------------- Cleaned up the header gunk to compile cleanly under GHC 7.10. No actual code has been altered. -------------------------------------------- -- Long description -------------------------------------------- In particular stm-chans offers the following data types: * Control.Concurrent.STM.TBChan: Bounded FIFO channels. When the channel is full, writers will block/retry. This ensures that the writers do not get too far ahead of the readers, which helps to make sure that memory and cpu resources are used responsibly. * Control.Concurrent.STM.TMChan: Closeable FIFO channels. * Control.Concurrent.STM.TMQueue: Closeable FIFO queues. Like TChan (Maybe a) but with a monotonicity guarantee that once Nothing is returned all future reads will be Nothing as well. * Control.Concurrent.STM.TBMChan: Bounded Closeable FIFO channels. * Control.Concurrent.STM.TBMQueue: Bounded Closeable FIFO queues. Combines the capabilities of TBChan and TMChan. -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/stm-chans Darcs: http://community.haskell.org/~wren/stm-chans Haddock (Darcs version): http://community.haskell.org/~wren/stm-chans/dist/doc/html/stm-chans -- Live well, ~wren

1 0

ANN: logfloat 0.13.3
by wren romano 30 Mar '15

30 Mar '15

-------------------------------------------- -- logfloat 0.13.3 -------------------------------------------- This package provides a type for storing numbers in the log-domain, primarily useful for preventing underflow when multiplying many probabilities as in HMMs and other probabilistic models. The package also provides modules for dealing with floating numbers correctly. This version drops support for Hugs and GHC < 7.8. Nothing major has changed, so they should still work; it's just that they're no longer officially supported. Thus, this version of the library provides a transitional point between backwards compatability and adding new features (see below). -------------------------------------------- -- Changes since 0.12.1 (2010-03-19) -------------------------------------------- * Monomorphized logFloat, logToLogFloat, fromLogFloat, and logFromLogFloat: that is, they all take/return Double now. The change was made to help reduce the need for explicit type signatures. It shouldn't really affect most users, since it seems noone was really making use of the polymorphism provided by previous versions. To get the previous behavior back, just explicitly add calls to realToFrac wherever necessary. * Fixed some instances to get them to compile under the new role-based type system of GHC 7.10 * Cleaned up various extraneous rewrite rules, specializations, etc * Added the functions sum, product, and pow. Both sum and product preserve more precision than the fold-based definitions in the Prelude. Moreover, sum is _much_ faster than the Prelude version, since it only requires crossing the log/exp boundary n+1 times, instead of 2*(n-1) times. The only downside is that sum requires two passes over the input and thus is not amenable to list fusion. -------------------------------------------- -- Upcoming changes (0.14+) -------------------------------------------- * Since the Data.Number.RealToFrac module is no longer required by any of the others, it will probably be forked off to a separate package in order to improve portability of the rest of the package by removing the need for MPTCs. * There's long been clamoring for adding a vector:Data.Vector.Unboxed.Unbox instance. I've been reluctant to add such an instance due to wanting to retain backwards compatibility and portability. Having dropped support for Hugs and older versions of GHC, I'm now willing to add them in. The logfloat library is conceptually quite simple, and thus to whatever extent possible I'd still like to retain portability to non-GHC compilers. So if you are interested in using logfloat with another compiler/interpreter but run into problems (e.g., due to the type families required by the vector library), please get in touch and I'll try to get things to work. -------------------------------------------- -- Compatibility / Portability -------------------------------------------- The package is compatible with GHC 7.8.3 and 7.10.1. It may still compile with older versions of GHC (or even Hugs!), however they are no longer officially supported. The package is not compatible with nhc98 and Yhc because Data.Number.RealToFrac uses MPTCs. However, that module is no longer required by any others, and all the other modules should be compatible with these compilers. Thus, it should be fairly easy to port. If you do so, please let me know and I'll try to incorporate support for them. -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/logfloat Darcs: http://code.haskell.org/~wren/logfloat/ Haddock (Darcs version): http://code.haskell.org/~wren/logfloat/dist/doc/html/logfloat/ -- Live well, ~wren

1 0

[announce] pipes-cliff - library for streaming to and from processes with Pipes
by Omari Norman 29 Mar '15

29 Mar '15

Sometimes you have to write Haskell code to interact with external processes. What a bother. The System.Process module makes it easy to send data in and out, but what if you want to stream your data in constant time and space? Then you need to cobble together your own solution using the provided Handles. Or you can use pipes-cliff, which lets you use the excellent Pipes library to stream your data in and out. Some simple examples in the package get you started. https://hackage.haskell.org/package/pipes-cliff Also, take a look at the README.md file, which lists some similar packages. Maybe one of those will work better for you. https://github.com/massysett/pipes-cliff/blob/master/README.md

1 0

OS X builds of GHC 7.8.4, 7.10.1-rc2, and 7.10.1-rc3
by Miëtek Bak 29 Mar '15

29 Mar '15

An OS X build of GHC 7.10.1-rc3 is now available, courtesy of Mark Lentczner. This is in addition to the GHC 7.8.4 and 7.10.1-rc2 builds Mark has made available on February 2. Thanks, Mark. GHC 7.8.4 for OS X can already be downloaded from haskell.org, even though it’s not mentioned on the GHC 7.8.4 webpage: https://downloads.haskell.org/~ghc/7.8.4/ghc-7.8.4-x86_64-apple-darwin.tar.… To avoid running up Mark’s bandwidth bill, I’m omitting the URL to his staging area. I’ve mirrored all three builds in Halcyon public storage: 7.8.4: https://halcyon.global.ssl.fastly.net/original/ghc-7.8.4-x86_64-apple-darwi… 7.10.1-rc2: https://halcyon.global.ssl.fastly.net/original/ghc-7.10.0.20150123-x86_64-a… 7.10.1-rc3: https://halcyon.global.ssl.fastly.net/original/ghc-7.10.0.20150316-x86_64-a… Binary builds of GHC, repackaged with documentation removed, are also available in Halcyon — on OS X 10.10, 10.9, 10.8, and a considerable number of Linux distributions. This includes GHC 7.10.1-rc3, 7.10.1-rc2, 7.8.4, 7.8.3, 7.8.2, 7.6.3, 7.6.1, 7.4.2, 7.2.2, and 7.0.4. Using Halcyon, installing GHC together with cabal-install is expected to take 20-30 seconds: https://halcyon.sh/tutorial/#install-ghc-and-cabal -- Miëtek https://mietek.io

1 1

Information about "definitive-base" prelude replacement
by Clinton Mead 29 Mar '15

29 Mar '15

I've played around a bit with "classy-prelude", but recently I stumbled into "definitive-base", on hackage here - https://hackage.haskell.org/package/definitive-base. The documentation is sparse, but there's some brief information here: https://marc.coiffier.net/projects/definitive-framework.html It looks interesting, but I was wondering if anyone has used it as a replacement prelude, and perhaps written/blogged on it? I'm just looking for a bit of a primer I guess.

2 1

LTS Haskell 2.0: Last call
by Michael Snoyman 29 Mar '15

29 Mar '15

This is the last announcement about the upcoming LTS 2 release, which is schedule for this Wednesday, April 1 (no joke). For those unfamiliar with the process: we will essentially be taking that day's Stackage Nightly and promoting it to LTS 2, and locking down the major versions of all packages in that package set until LTS 3. If you'd like to get any additional packages in, please send your pull requests now[1]. I'd also like to call attention to the current upper bounds issues[2]. If we can get any of these issues resolved before Wednesday, then newer versions of the relevant packages can make it into LTS 2. Otherwise, LTS 2 will continue with the old versions. (Alternatively, we can consider dropping the packages with restrictive upper bounds, if there's demand to do so.) Things worth pointing out: * primitive 0.6 is out, and introduces very minimal breaking changes. If you can get your packages to support the new version (likely with just a cabal file change), that would be great. * criterion 1.1 is out. I may simply disable benchmarks on the relevant users to allow the new version to slip in. * QuickCheck 2.8 would be a nice addition * lens 4.8 is blocked on a number of diagrams-* packages and a few others. I have no idea how complicated the changes are there. * blaze-builder 0.4 is blocked by snap, and unlikely to unblock in time, which likely means we'll have two ByteString Builder variants for this release * wizards depends on an old control-monad-free Thanks for everybody's participation! [1] https://github.com/fpco/stackage#get-your-package-included [2] https://github.com/fpco/stackage/issues?q=is%3Aopen+is%3Aissue+label%3Aboun…

1 0

cabal install wx failures
by Jeffrey Brown 29 Mar '15

29 Mar '15

Hi, I switched OSs to change other problems and in the process lost wxHaskell. The first time I tried to add it to my new system, cabal install wx gave me more output, installing a lot of things. Since then it has only given this: jeff@linux-ee07:~> cabal install wx Resolving dependencies... [1 of 1] Compiling Main ( /tmp/wxc-0.91.0.0-16672/wxc-0.91.0.0/Setup.hs, /tmp/wxc-0.91.0.0-16672/wxc-0.91.0.0/dist/setup/Main.o ) Linking /tmp/wxc-0.91.0.0-16672/wxc-0.91.0.0/dist/setup/setup ... Configuring wxc-0.91.0.0... Warning: No config found to match: /usr/bin/wx-config --version=2.9 --version-full in /usr/lib64/wx/config If you require this configuration, please install the desired library build. If this is part of an automated configuration test and no other errors occur, you may safely ignore it. You may use wx-config --list to see all configs available in the default prefix. readProcess failed: readProcess: wx-config "--version=2.9" "--version-full" (exit 1): failed Configuring wxc to build against wxWidgets 3.0.2.0 Building wxc /usr/bin/gcc -Wl,--hash-size=31 -Wl,--reduce-memory-overheads -Wl,--disable-new-dtags -Isrc/include -I/usr/include/wx-3.0 -I/usr/lib64/wx/include/gtk3-unicode-3.0 -D__WXGTK__ -DWXUSINGDLL -DwxDEBUG_LEVEL=0 -D_FILE_OFFSET_BITS=64 -DwxcREFUSE_MEDIACTRL -fPIC -c src/cpp/apppath.cpp -o dist/build/src/cpp/apppath.o gcc: error trying to exec 'cc1plus': execvp: No such file or directory Failed to install wxc-0.91.0.0 cabal: Error: some packages failed to install: wx-0.91.0.0 depends on wxc-0.91.0.0 which failed to install. wxc-0.91.0.0 failed during the building phase. The exception was: ExitFailure 1 wxcore-0.91.0.0 depends on wxc-0.91.0.0 which failed to install. jeff@linux-ee07:~> The file /usr/bin/wx-config exists. It may have gotten there today when I installed some wx packages via zypper (because I use openSuse). I don't remember which, but in the wx-configg file appear these lines: this_version="3.0" [ -z "$output_option_release" ] || echo "3.0" [ -z "$output_option_version" ] || echo "3.0.2" [ -z "$output_option_version_full" ] || echo "3.0.2.0" so I believe the version of wx I have is 3.0.2.0. I'm running OpenSuse 13.2 on a Lenovo Thinkpad Edge 535 or 545. Thanks, Jeff

1 1

Command Line Args passed to wxHaskell
by Michael Jones 28 Mar '15

28 Mar '15

I am seeing strange behavior with a wxHaskell app compiled on Windows 7. On Linux, all is well. I can call my app like: app +RTS -N4 -RTS myArg And in the app I can process the myArg and start a wxHaskell frame. When I compile the same application on Windows 7, I get an error dialog box that says: “Unexpected parameter `+RTS`. And a second Usage dialog that looks like it comes from wxHaskell. I am not sure why Windows is different, but perhaps it is the fact that on Windows 7 I compiled up wxHaskell 0.92, and on Linux I used 0.91 from a cabal update. I used 0.92 on on Windows because I could not get 0.91 to compile due to some type problems where the wxPack version was incompatible with a header file and the Haskell compiler related to 64 bit types long long. There is some noise about this on the web, but no solutions. Nonetheless, I assume that args are grabbed directly by wxHaskell and Environment.getArgs does not consume them such that they are still available to wxHaskell. Is there some way to consume arguments so they are no longer available or a way to modify them so that when wxHaskell starts up it sees arguments I can control in code? In wx there is an API to set arguments, but it does not seem to be part of wxHaskell. So I think I need something I can do outside the wxHaskell API. Mike

1 1