- Haskell-Cafe - Haskell.org

dph question
by Warren Harris 15 Oct '10

15 Oct '10

I trying to learn a bit about data parallel haskell, and started from the wiki page here: http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell. Two questions: The examples express the dot product as: dotp_double xs ys = sumP [:x * <http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:.> y | x <- xs | y <- ys:] Unless I'm missing something, shouldn't this actually be: dotp_double xs ys = sumP [:x * <http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:.> y | x <- xs, y <- ys:] Second, when I run Main with the prescribed 10000 element array, everything seems to work quite nicely. The task takes about 2 seconds on my 4 processor x86_64, and threadscope shows all processors nicely utilized. However, when bumping this to 100000 elements, rather than taking 10x longer as I expected, the process never terminates. During one run I even lost control of my machine and needed to do a hard reset. Are there known limits to the array sizes that can be handled with dph, or can someone suggest what might be going wrong here? Thanks, Warren

3 3

All binary strings of a given length
by rgowka1 15 Oct '10

15 Oct '10

Hi - How can I generate all binary string of a given length? The type signature would something like - genbin :: Int -> [String] For example genbin 2 would give ["00","11","01","10"] and genbin 3 would give ["000","001","010","011","100","101","110","111"] etc.. thanks..

6 9

Fwd: [Haskell-cafe] Fuzzy time deltas
by Alberto G. Corona 15 Oct '10

15 Oct '10

Michael, The package Workflow has persistent timeouts (can wait for years and restart on system failure if embedded in the workflow monad, although it can run in the IO monad, with no recovery). They are composable with any action in the STM monad with orElse: flag <- getTimeoutFlag $ 5*24*60 * 60 -- wait exactly 5 days. even -- if the program restart ap <- step . atomically $ readSomewhere >> return False `orElse` waitUntilSTM flag >> return True case ap of False -> print "something received" True -> print "timeout" step" lift it from the IO to the workflow monad, and gives it persistence and recovery. without "step", it runs in the IO monad (No recovery on system failure): flag <- transientTimeout $ 5*24*60 * 60 -- wait 5 days, timeout -- restarts in case of failure ap <- atomically $ readSomewhere >> return False `orElse` waitUntilSTM flag >> return True case ap of False -> print "something received" True -> print "timeout" ------ transientTimeout t= do flag <- atomically $ newTVar False forkIO $ threadDelay(t * 1000000) >> atomically (writeTVar flag True) >> myThreadId >>= killThread return flag 2010/10/14 Michael Snoyman <michael(a)snoyman.com>: > Hey all, > > Is there a library that supports fuzzy time deltas? For example, given > two UTCTimes (or something like that) it could produce: > > 43 seconds > 13 minutes > 17 hours > 4 days > 8 months > > I want to use it for the news feature on Haskellers. It's not that > hard to write, just wondering if it's already been done. > > Michael > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

allocation for "pure" FFI functions
by Johannes Waldmann 15 Oct '10

15 Oct '10

Hi. I wonder how to do the following properly. I have one (large) C type, let's call it T, and I want to sell it as an abstract type in Haskell. I want to use C functions as if they were of type T -> T (pure function, returns a modified copy of the input) and the question is, how to do the memory allocation for that, in particular, how to avoid IO showing up in the (visible) types on the Haskell side: I don't want IO because I don't want to declare some artificial order of execution - instead I want lazy evaluation. E.g., I might have some Haskell record with a T component which may or may not be evaluated (accessed) at all. I came up with two straightforward approaches that don't work: Version 1: the C function does "malloc" on its own, and returns a Ptr. So far, this is pure (no IO). Problem: to make the "free" happen, I need to add a finalizer in Haskell, and this is IO. Version 2: allocation on the Haskell side with mallocForeignPtr. Problem: this is already in IO. Is there a solution? Workaround? Better approach? If it boils down to unsafePerformIO, then where do I put it, and what should I watch out for? J.W.

4 4

deploying applications that use plugins
by Stefan Kersten 15 Oct '10

15 Oct '10

hi all, i am working on an application that evaluates haskell code entered by the user using the plugins package [1]; now i want to deploy the application as a self-contained .app bundle on OSX, i.e. the end user should not have to install anything in addition. what do i need to bundle in order for plugins to work on a vanilla machine? i suppose i need ghc in PATH and have to ship modified versions of the package.conf files that point to the corresponding libraries within the application bundle? is there a parser for package.conf files? any pointers would be greatly appreciated! thanks, <sk> [1] http://hackage.haskell.org/package/plugins

1 0

Thunks
by Mihai Maruseac 15 Oct '10

15 Oct '10

Hi, Is there a way to determine the order in which thunks are created and expanded/evaluated in Haskell (GHC)? I'm looking mainly at some existing interface but if there is only something in the GHC source it will suffice. Thanks, -- Mihai

5 6

Re: MonadCatchIO, finally and the error monad
by oleg＠okmij.org 15 Oct '10

15 Oct '10

Michael Snoyman wrote: > I have a recommendation of how to fix this: the MonadCatchIO typeclass > should be extended to include finally, onException and everything > else. We can provide default definitions which will work for most > monads, and short-circuiting monads like ErrorT (and I imagine ContT > as well) will need to override them. It seems that `finally' can be fixed without all these proposed additions. The method catch is the only necessary method of the class. The subject of catching errors in non-IO monads has a long history, some of which is documented at http://okmij.org/ftp/Haskell/index.html#catch-MonadIO The page points out to an old CaughtMonadIO file. I have just updated it for new Exceptions, and added the final test: > test3c go = runErrorT $ go `gfinally` (liftIO $ putStrLn "sequel called") > test31 = test3c (return "return" :: ErrorT String IO String) *CaughtMonadIO> test31 sequel called Right "return" > test32 = test3c (error "error" :: ErrorT String IO String) *CaughtMonadIO> test32 sequel called *** Exception: error > test33 = test3c (throwError "throwError" :: ErrorT String IO String) *CaughtMonadIO> test33 sequel called *** Exception: ErrorException "\"throwError\"" As we can see, sequel is always called. Here is the updated file: http://okmij.org/ftp/Haskell/CaughtMonadIO.lhs Incidentally, one should be very careful of using `finally' with the continuation monad. The Cont monad lets us ``enter the room once, and exit many times''. So, finally may be called more than once. We need the ugly dynamic-wind -- or try to use less powerful monads if they suffice.

2 3

Cobbled together a version of Haskell Platform 2010.2 that works for GHC 7.1
by Ryan Newton 15 Oct '10

15 Oct '10

Well, it's not 2010.2 anymore because I had to upgrade a few packages ;-), but if you want to try out some of the new GHC 7 features this can get you a working cabal-install. Download here: http://parfunk.blogspot.com/2010/10/hacking-together-working-version-of.html Apologies if this is already available somewhere, but I didn't see it. Cheers, -Ryan

1 0

ANNOUNCE: Facts
by Alexander Solla 14 Oct '10

14 Oct '10

The Facts hierarchy is meant to contain commonly used, relatively static facts about the "real world". The facts are meant to be encoded using relatively simple Haskell constructs. However, we do make some promises: every data type our modules export will have instances of Data, Eq, Ord, Show, andTypeable. We will use explicit module export lists to control access to internal data structures. As much of the data we are encoding is tabular, we use simple structures like lists and maps to encode the relations. This has two practical ramifications: the textual representation of the data can be very wide, but are also very easy to edit, with "block editing" tools like Vi's visual block mode. The other consequence is that the naive approach to writing queries can be tedious, and the resulting naive queries are slower than they could be. Template Haskell can eliminate much of this drudgery. Felipe Lessa has graciously donated some Template Haskell code which we have adapted. The Facts.* hierarchy currently contains modules with geographical information, such as a data type of countries, cross references to various ISO-3166-1 names for each, a list of states in the United States, and the United States address format. Please see the module hierarchy for more specifics. Patches are welcomed, though prospective contributors are encouraged to encode data structures using lists of pairs to encode bijections, all exposed data types are instances of Data, Eq, Ord, Show, and Typeable, and use explicit exports to only export queries and their atoms. For now, we will add facts to the hierarchy lazily, as our projects need them.

2 2

ANNOUNCE: polyToMonoid
by Kevin Jardine 14 Oct '10

14 Oct '10

Polyvariadic functions that accept an indefinite number of possibly multiple typed arguments are often useful but a bit difficult to declare in Haskell. With some crucial assistance from Oleg Kiselyov, I have created a library that supplies two very general polyvariadic functions that can map their arguments into any monoid you specify. All you need to do to use these is to specify the monoid and some instances of a toMonoid function to map all the types you want to pass as arguments into the monoid. The functions can act as a sort of generalised list, but of course there are also many interesting monoids which are not lists. The library is now up on Hackage here: http://hackage.haskell.org/package/polyToMonoid-0.1 along with detailed documentation and a few examples here: http://hackage.haskell.org/packages/archive/polyToMonoid/0.1/doc/html/Data-… As you can see, the code is short and depends only upon the GHC base library. The original thread discussing the polyToMonoid idea is here: http://groups.google.com/group/haskell-cafe/browse_thread/thread/737c6cf921… Comments and suggestions for improvement are welcome! Kevin

1 0