- Haskell-Cafe - Haskell.org

Re: [Haskell-beginners] Start file with associated prog (windows only?)
by Max Desyatov 18 Aug '09

18 Aug '09

Bernhard Lehnert <b.lehnert(a)gmx.de> writes: >> Windows has a command "start" which you can use e.g. via System.Process.proc. > > Thank you, Magnus - this is exactly what I was looking for. (By the way, > someone should implement something like this for GNOME and KDE, > too ;-) ) You can do that using MIME, look at /etc/mailcap, it already contains all what you need to run appropriate process for exact MIME-type. As long as it's supported in your distribution.

2 1

Installing documentation with cabal
by Maciej Piechotka 18 Aug '09

18 Aug '09

Is it possible to automatically (or non-automatically) install documentation when installing package with cabal-install? Regards

2 2

Library function for map+append
by Dusan Kolar 18 Aug '09

18 Aug '09

Hello all, During a small project I'm trying to develop a small application. It becomes quite often that I need a function mapapp: mapapp _ [] ap = ap mapapp f (a:as) ap = f a : map f as ap I tried hoogle to find such a function with no success. Is there any function/functions built-in "standard" libraries that could easily satisfy the functionality with the same or even better (?) efficiency? Of course, (map f list) ++ append would do the same as mapapp f list append but with less efficiency. Or am I wrong? Thanks Dusan

9 14

Looking up functions inQ monad (Template Haskell).
by Zefirov Sergey 18 Aug '09

18 Aug '09

Why isn't possible to lookup and call user-defined functions while performing Template Haskell actions? Just like the way Template Haskell looks up and calls 'f' in $(f ...). 'f' gets looked up and called. And user of Q monad cannot do that. A colleague of mine, a Lisp user, says that almost everything is in place. It's just not enabled. Is there any problem we do not understand?

2 1

ANN: OpenCLRaw 1.0.1000
by Jeff Heard 18 Aug '09

18 Aug '09

All, I've released a raw binding to the OpenCL platform on Hackage. The main differences between it and the C bindings are that constants have been replaced by newtypes for type safety reasons, void-essential functions that return a token errorcode return a Maybe ErrorCode, and functions that return a handle/ptr and return an error-code through an out-parameter return instead an Either ErrorCode a. Modules are grouped roughly by the section in which they appear in the standard. I'm working on an OpenCL binding that is a little more "cooked" as well as a high-level OpenCL binding. OpenCL is a platform for single-host heterogenous, data-parallel computing that follows roughly the OpenGL and OpenAL conventions for how the library is architected. It will be available by default in the next version of Apple's OS-X, and there are drivers for AMD Opteron/Athlons and nVidia CUDA-based graphics cards. The basic procedure behind running an OpenCL program is: 1. get a list of platforms 2. choose a device on the platform that fits your needs 3. create a context for the platform and the device 4. compile a program and "kernels" written in OpenCL/C 5. create memory buffer objects. 6. execute kernels on the memory buffer objects. 7. rinse hands, repeat. Obviously this is not very functional, but we can't get there without a raw binding. Data Parallel computing is somewhere Haskell is excelling; hopefully this will generate some interest in creating a DPH binding to OpenCL's C99-based language, OpenCL/C.

2 2

Re: [Haskell-cafe] Can't install Haskell Platform on 64-bit Linux
by Colin Paul Adams 18 Aug '09

18 Aug '09

>>>>> "Magnus" == Magnus Therning <magnus(a)therning.org> writes: Magnus> Ouch, there only seems to be a version of 6.10.3 in Fedora Magnus> 11, if I read this correctly: Magnus> https://admin.fedoraproject.org/pkgdb/packages/name/ghc Magnus> (I'm not a Fedora user so I might be completely confused Magnus> here :-) Magnus> It looks like the pre-built ghc can't find the installed Magnus> libgmp. I don't think it's a problem with libgmp. I think that's just a cautionary message, based on experience that this is a common error. -- Colin Adams Preston Lancashire

1 0

Grouping and SIMD in parallel Haskell (using Nested Data Parallel Haskell ideas in legacy code)
by Zefirov Sergey 18 Aug '09

18 Aug '09

I haven't had enough time to polish a paper about the subject, so I decided to post my results here, in Haskell Café. When Simon Peyton-Jones was in Moscow about a month ago I made a bold statement that Parallel Haskell programs, expressed with the help of par and pseq, can be transformed into Nested Data Parallel Haskell. I wrote a simple model of what will be if we group arguments of par and pseq into queues based on parallel arrays from NDPH. We could then evaluate all thunks from that queues in parallel using SIMD (or just getting higher ILP). We also do not have to lock out main spark queue, we lock only queue we should put argument in. The latter turned out to be beneficial in itself, at least in my simple model. Let us look at famous parallel fib function: Fib n | N <= 1 = 1 | otherwise = a `par` b `pseq` a+b where a = fib (n-1) b = fib (n-2) When we evaluate fib we put a spark of a into spark queue and proceed to evaluate b and, then, a+b. When we put a into spark queue, we lock queue out, modify and release. There is a big probability that threads on different cores will compete for queue lock and some of them (most of them) will waste time waiting for lock release. If we group a's into different queue and put to main spark queue a spark to evaluate a complete group of a's at once, we will get less wasted time. This will work even for single CPU. Below is a run of (fib 15) on my model with cpuCount 1, 4 and 16 and a's or b's group length 0 (no grouping) and 16: cpuCount groupLength=0 groupLength=16 modelTicks modelTicks 1 34535 27189 4 12178 7472 16 7568 3157 speedup 2.19 times 3.11 times ticks1/ticks16 I think results speak for itself. I think the idea of `par` argument grouping could be viable. I should note that I made several digressions when I wrote model. One of digressions is that all evaluations are put into queue. In (a `par` b `pseq` a+b) a put into a_queue, b put into b_queue and (a+b) put into main queue. Each evaluated spark update it's "parent" - a spark that wait for it. Also, main loop of single CPU changed from simple (reading main spark queue + execute when get something) into a series of attepmts with fall back on failure: - first read main queue and execute spark if succeed, - else read current a_queue and execute all sparks there if succeed, - else read current b_queue and execute all sparks there if succeed, - else go to main loop. The new (transformed) code for our fib below: -- |Create a new queue based on parallel array. It holds a parallel array with current arguments and a function that performs -- computation in RTS monad (evaluation function). newQueueParArray :: (x -> RTS ()) -> RTSRef ([: x :],x -> RTS ()) a_queue = unsafePerformIO $ newQueueParArray (\x -> fib (x-1)) -- RTSRef (Int,Int -> Int) b_queue = unsafePerformIO $ newQueueParArray (\x -> fib (x-2)) -- RTSRef (Int,Int -> Int) fib n caller | n <= 1 = 1 | otherwise = unsafePerformIO $ do Ab <- addToMainQueue (defer (+) caller) A' <- addToParArrQueue a_queue x ab B' <- addToParArrQueue b_queue x ab addToMainQueue ab -- add a spark to check a' and b' evaluation status, compute a+b and update the caller. That transfomation cannot be done at the source level using usual type (class/families) hackery. It could be done, though, using core-to-core transformations. It is clear that several values of same type (Int for fib) and a function to perform operations over them leads to SIMD execution. I made some provisions to exploit SIMD and ILP in my model. It can load more than single task information and add several values per cycle. This also speeds execution up, but not so radically (about 3%). The source code for model is here: http://82.146.47.211/attachment/wiki/ndpph/ndp-ph.hs (it's a MskHUG.ru domain, we have temporary problems with DNS). It short of comments, but I tried to make understandable function names. Compile it with 'ghc -o ndp-ph --make -O2 ndp-ph' and run with a command line like the following: ndp-ph.exe cpuCount 1 usePrivateGroups 0 maxABTaskLength 64 taskFetchsPerCycle 1 thunksPerAddition 8 cyclesPerAddition 1 I decided to create a model of exexcution instead of modifying an existing implementation because I have not enough time. I wrote it over evenings and a weekend, so it is simple, it's rude and it does the job pretty fine.

2 2

Can't install Haskell Platform on 64-bit Linux
by Colin Paul Adams 18 Aug '09

18 Aug '09

I installed GHC 6.10.4 (as ./configure said it was required) from a .bz2 file on the GHC downloads page. I then tried ./configure for the platform again, and got: checking ghc actually works... no configure: error: Your installation of ghc does not appear to work. It cannot compile a simple program (see config.log for the details). If you installed ghc from a generic binary tarball then it is worth checking that you have the 'gmp' C library and header files installed. (On debian-based systems this package is called libgmp3-dev.) Looking in config.log, I see: configure:2287: checking ghc actually works configure:2296: /usr/local/bin/ghc -o conftest conftest.hs /tmp/ghc22651_0/ghc22651_0.s: Assembler messages: /tmp/ghc22651_0/ghc22651_0.s:43:0: Error: suffix or operands invalid for `push' /tmp/ghc22651_0/ghc22651_0.s:89:0: Error: suffix or operands invalid for `push' /tmp/ghc22651_0/ghc22651_0.s:135:0: Error: suffix or operands invalid for `push' configure:2299: $? = 1 configure: failed program was: main = putStr "Hello world!\n" -- this file generated by TRY-COMPILE-GHC end of failed program. configure:2308: result: no configure:2314: error: Your installation of ghc does not appear to work. It cannot compile a simple program (see config.log for the details). If you installed ghc from a generic binary tarball then it is worth checking that you have the 'gmp' C library and header files installed. (On debian-based systems this package is called libgmp3-dev.) Libgmp is installed. I don't know the significance of the assembler error messages. If I type from the command line: ghci I get the Prelude> prompt, so it looks like the installation is OK at first glance. What should I check next? -- Colin Adams Preston Lancashire

2 2

Request for Comments - hscurrency 0.0.1
by Max Cantor 17 Aug '09

17 Aug '09

Hi all, I'm putting together some simple tools to do safe calculations on different currencies. For instance, making sure that you dont add something like 5 USD + 10 JPY without doing a proper conversion. I've put up some code on google code which probably explains what I'm trying to do more succinctly than this email. I'm curious what poeple think about the library, its the first haskell code I've written for the purpose of sharing and I intend to add it to hackage once I finalize the interface a bit more. The code is at: http://bit.ly/1Cjjlj I'm very open to suggestions on improving the interface. RIght now its very simple and straightforward but potentially limited. I originally wrote it so that the Prc type would be an instance of several numerical classes but eventually stripped that out as it required returning undefined in several cases (such as calling toIntegral on a Prc which was a composite of several currencies). I felt it was better to avoid having partial functions.. Max

5 5

simple hsql question
by Alexander Kotelnikov 17 Aug '09

17 Aug '09

Hi I wanted to see what access to databases HSQL provides and I stumbled in the very beginning. Assume I have a table map1 with attributes "i" and "s" interger and varchar() respectively. The following code fails (with segfault) for me. And I see no other way to tell compiler that I am expecting an interger to be found as 'i' in a fetched row. import Database.HSQL import Database.HSQL.MySQL main :: IO () main = do c <- connect "localhost" "tx_test" "sacha" "" s <- query c "SELECT i FROM map1" print $ getFieldsTypes s i <- (getFieldValue s "i")::IO Int print i disconnect c -- Alexander Kotelnikov Saint-Petersburg, Russia

2 2

Re: Changelogs and "available since"
by Max Desyatov 17 Aug '09

17 Aug '09

Laszlo Nagy <rizsotto(a)gmail.com> writes: > Hi All, > > I was volunteer to solve this problem: > <http://hackage.haskell.org/trac/summer-of-code/ticket/1565> > In a conversation on the libraries(a)haskell.org I was suggested to > scratch my idea here. > > > I would use hoogle for this. Currently it stores the package name and > the symbols of the modules about a package. What do you think about hayoo? I prefer this to hoogle, as hayoo has more complete database across hackage packages, AFAIK > I would extend it to store > the version of the package as well. Extend the query methods to use > all the available package description at search. And make a > VersionRange from the matched Versions. I wrote some code for doing this a while ago. Take a look and make some comments, I can extend this library to satisfy your needs http://hackage.haskell.org/package/cabal-query

3 2

REMINDER: Next BostonHaskell meeting TOMORROW (August 18th) at MIT
by Ravi Nanavati 17 Aug '09

17 Aug '09

The full details of the event are here: http://groups.google.com/group/bostonhaskell/browse_thread/thread/71243e7d2… I'm just sending out this reminder to make sure more people hear about the event (especially as, with Brent on vacation, there wasn't a Haskell Weekly News this week). If you're planning to come please respond to our scheduling poll at: http://doodle.com/participation.html?pollId=x8rbbbprtezdtaan This will help us get a better count of attendees for refreshments (since my wife has volunteered to make more baked goodies). Please also respond to the poll if you're interested in BostonHaskell, but couldn't come this month because of scheduling or location constraints. That will help us improve planning for future meetings. I look forward to seeing many Boston-area Haskellers tomorrow! Thanks, - Ravi Nanavati

1 0

Got problems with classes
by Grigory Sarnitskiy 17 Aug '09

17 Aug '09

Hello! I can't understand why the following dummy example doesn't work. {-# OPTIONS -XTypeSynonymInstances #-} {-# OPTIONS -XFlexibleInstances #-} module Main where import Data.Array.Unboxed class Particle p type ParticleC = (Double, Double, Double) instance Particle ParticleC class Configuration c where getParticleI :: (Particle p) => c -> Int -> p type Collection p = UArray (Int,Int) Double instance Configuration (Collection p) where getParticleI config i = (1,1,1) :: ParticleC

4 4

Credit Suisse is hiring
by Sittampalam, Ganesh 17 Aug '09

17 Aug '09

Hi, Just to chime in with the spate of job advertisements, the Global Modelling and Analytics Group (GMAG) at Credit Suisse is once again looking to hire functional programmers. The group consists of about 130 people worldwide. The majority of the group are mathematicians engaged in developing mathematical models for financial products traded by the division. Approximately 20 people are primarily computing experts, based in the Architecture and Delivery (AD) subgroup within GMAG, and successful candidates will also be based in this group. We are already making heavy use of functional programming within the group, and we expect to increase this in the future. Some information about our Haskell projects can be found here: http://www.haskell.org/communities/05-2009/html/report.html#creditsuisse ; more recently we have adopted F# for implementing and deploying models on the .NET platform and we are currently ramping up our F# usage. Our team works closely with the modellers to help them leverage functional programming to improve the design of their code. Key requirements: At least one of: - An academic track record in functional programming. - Significant experience of "real-world" computing environments, preferably using functional programming. Excellent communication skills in order to convey new ideas to our modelling team. Location: London or New York Contact: Howard Mansell <howard.mansell(a)credit-suisse.com> Myself (Ganesh Sittampalam <ganesh.sittampalam(a)credit-suisse.com>) and Tobias Gedell <tobias.gedell(a)credit-suisse.com> will be attending ICFP 2009 and associated workshops in Edinburgh - if you'd like to discuss this in person, get in touch with us by email, or just grab one of us there. Background information: As one of the world's leading banks, Credit Suisse provides its clients with investment banking, private banking and asset management services worldwide. Founded in 1856, Credit Suisse has a long tradition of meeting the complex financial needs of a wide range of clients, offering advisory services, comprehensive solutions and innovative products to companies, institutional clients and high-net-worth private clients globally. Credit Suisse is active in over 50 countries and employs approximately 46,000 people. Further information can be found at www.credit-suisse.com. Cultural diversity is essential to our success. As such, we employ people from more than 100 countries. Credit Suisse empowers employees to work openly and respectfully with each other and with clients, ultimately striving to deliver superior results while offering initiatives and programs to assist employees achieve a healthy work-life balance. The Global Modelling and Analytics Group (GMAG) is responsible for producing state-of-the-art pricing, trading and risk management models for Credit Suisse. These models are used across a range of businesses in the Fixed Income and Equity departments. The group performs the full spectrum of quantitative work, from mathematical modelling through software implementation and delivery, to risk analysis of trades and existing portfolios. The group's mandate covers all major asset classes, including Credit Derivatives, Commodities, Emerging Markets, Equity Derivatives and Convertibles, Exotics, Foreign Exchange, Fund Linked Products, Interest Rate Products and Mortgage Derivatives. GMAG operates globally with members located in London, New York, Hong Kong, Tokyo, Zurich and São Paolo. Established in 1990, GMAG stands out as a unified quant group that has been covering all major product areas since its inception. The group has always enjoyed a strong relationship with Trading, Structuring and Sales, assisting them with trade pricing and risk management. As the group is based on the trading floor, it is ideally placed to respond to the financial modelling needs of the businesses it supports. The breadth of GMAG's mandate makes it uniquely positioned to leverage the skills and experience of its members, and to provide a consistent modelling approach across all areas. Over time, the group has developed an extensive suite of pricing models on a common platform with complete integration across all asset classes. Quantitative Analysts in GMAG carry out a range of activities which include the creation of sophisticated mathematical models for the valuation of complex derivatives, development of the technology platform used to deliver models and driving the use of these models throughout the bank. Our Quantitative Analysts typically hold an advanced quantitative degree, have excellent analytical and problem-solving skills, demonstrate creative thinking, have strong programming skills, and are confident communicators. =============================================================================== Please access the attached hyperlink for an important electronic communications disclaimer: http://www.credit-suisse.com/legal/en/disclaimer_email_ib.html ===============================================================================

1 0

Re: [Haskell] ANNOUNCE: GLUT 2.2.1.0
by Rafael Gustavo da Cunha Pereira Pinto 17 Aug '09

17 Aug '09

Thanks Sven! BTW, as an enhancement for 2.2.2.0, you could treat unnamed mouse buttons. Mouses with more axis and more buttons are becoming increasingly common, and "unmarshalMouseButton" is not prepared to accept them!! Here are exceptions I caught, playing with my Genius Traveler 515 mouse: unmarshalMouseButton: illegal value 5 unmarshalMouseButton: illegal value 6 unmarshalMouseButton: illegal value 7 unmarshalMouseButton: illegal value 8 Anyway, keep the good work! Best Regards, Rafael On Sun, Aug 16, 2009 at 13:12, Sven Panne <Sven.Panne(a)aedion.de> wrote: > A new version of the GLUT package has been uploaded to Hackage. > > * The package is now autoconf-free. API entries are resolved dynamically > at > runtime, just like the OpenGLRaw and GLURaw packages. > > * Support for sRGB framebuffers has been added, just use SRGBMode with > initialDisplayMode. To use this functionality, you need the upcoming > freeglut > 2.6.0 library, older versions and "classic" GLUT do not support this > feature. > > * Support for context profiles has been added via initialContextProfile. > Again, this works with the upcoming freeglut 2.6.0 library only. > > Cheers, > S. > _______________________________________________ > Haskell mailing list > Haskell(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell > -- Rafael Gustavo da Cunha Pereira Pinto

3 3

Elerea/GLFW Tetris
by jean legrand 17 Aug '09

17 Aug '09

Hi Haskellers, Here is my first real program in Haskell. http://hpaste.org:80/fastcgi/hpaste.fcgi/view?id=8211 In fact, I'm not fully responsible because it's just an adapted version of a Tetris Creighton Hogg had written for Reactive/GLUT. As the first version, it's a very simple game (no levels, no points ...) but it's playable ! The major problem is when the board is full, the program sadly stops for an empty list : indeed, I wasn't interested in that part and I prefered dealing with the signals. As the frame is the same as the breakout frame, it is also possible to launch the game with ./Tetris --dump-dot | dot -Tsvg -o tetris.svg in order to get an svg showing a graph of the signals. Any help is welcome to understand this graph ! Every comment is welcome (especially about the first 170 lines). Enjoy!

2 3

Getting highest sum of list elements with Map
by gwern0＠gmail.com 17 Aug '09

17 Aug '09

(Full source attached; or alternately, grab it: darcs get http://community.haskell.org/~gwern/hcorpus ) So I have this little program which hopefully will help me learn French by picking, from a textfile/corpus the most 'valuable' word to learn - the word that will complete or bring closer to completion the most sentences in that corpus. It's a relatively straightforward problem, but efficiency is an issue. It can handle up to a book in length just fine, but at 10x that, it eats all my RAM and seems as if it will run indefinitely. (I haven't let it run long enough to find out.) The profiling fingers the method I would expect, one 'ranks' at ~80% of runtime, but it doesn't get any more specific than that, alas. The inner loop goes: fidiv :: (Integral a, Fractional b) => a -> a -> b fidiv = (/) `on` fromIntegral swap :: (a, b) -> (b, a) swap = uncurry (flip (,)) ranks :: (NFData v, Ord k, Ord v) => Map.Map k (Set.Set v) -> Maybe (Rational, v) ranks s = listToMaybe . sortBy (flip compare) . pmap swap . Map.toList . Map.fromListWith (+) $ [(word, 1 `fidiv` Set.size wrds) | (_sentenceId, wrds) <- Map.toList s , word <- Set.toList wrds] approximation :: (NFData v, Ord k, Ord v) => Map.Map k (Set.Set v) -> Int -> [v] approximation _ 0 = [] approximation s n = case ranks s of Nothing -> [] Just (_value, word) -> let withoutWord = Map.map (Set.delete word) s in word : approximation withoutWord (n-1) The inside of 'ranks' is generating a list which will look like [("foo", 0.2), ("bar", 0.0), ("foo", 0.5)...]; we insert into an empty Map, using the word as the key, and incrementing the existing value (so with that example we'd have {"foo" -> 0.7, "bar" -> 0.0}, and then we immediately convert *back* to a list, swap the tuple elements, and sort the whole blessed thing. I can't help but think that this is rather inefficient, and not the most straightforward way to go about it. But poring through Data.Map, I can't figure out what the right thing to do is. Obviously I only want to pull out the key/string with the maximum Rational value, but all the min/max functions work only on the *key*, not the value. Am I missing something, or am I using the wrong data structure, or what? -- gwern

4 3

Request for comments - hdnsomatic
by Jesús Alberto Sánchez Pimienta 17 Aug '09

17 Aug '09

Hello haskellers, I just finished my first useful haskell program and I'd be glad if you make me some comments http://hpaste.org/fastcgi/hpaste.fcgi/view?id=8244#a8244 Thank you, and sorry for my english. "Piensa y trabaja" Jesús Alberto Sánchez Pimienta Estudiante de la Lic. en Estudios Políticos y Gobierno Universidad de Guadalajara

2 3

Re: [Haskell-beginners] Ambigous Types with Haskell Functional Graph Library
by Max Desyatov 17 Aug '09

17 Aug '09

Joe <joesmoe10(a)gmail.com> writes: > I tried using ucycle directly from Data.Graph.Inductive.Example by > itself. > > I didn't realize there were two instances of Graph. How would you use the > PatriciaTree Graph instance in the ucycle type signature? > > ucycle :: Graph gr => Int -> gr () () You must have that Graph instance in scope. I can't give any more suggestions as I don't see the code in which you use `ucycle`.

1 0

ANNOUNCE: compose-trans-0.0
by Miguel Mitrofanov 17 Aug '09

17 Aug '09

Just uploaded compose-trans-0.0 to Hackage. 'compose-trans' is a small library intended to make monad transformers composable. It provides a class TransM, derived from MonadTrans, which is closed under composition - that is, if t1 and t2 are instances of TransM, then (t2 :. t1) is also an instance of TransM (and, therefore, an instance of MonadTrans), and the type ((t2 :. t1) m x) is isomorphic to (t2 (t1 m) x). It's fairly easy to make a new transformer an instance of TransM; it only takes one short line of code. There are also TransP and TransF classes, that help dealing with MonadPlus and MonadFix instances.

1 0

Calling function with unknown number and type arguments
by Maciej Piechotka 17 Aug '09

17 Aug '09

I have to write a function which calls a function with unknown (i.e. given in runtime) number and type of arguments. 1. Use closure implementation from Gtk2Hs. Pros: Written Cons: Not in haskell 2. Use unsafeCoerce. Something like: f a b = return (a + b) f' = unsafeCoerce (f :: Int -> Int -> IO Int) :: IO () unsafeCoerce (unsafeCoerce ((unsafeCoerce f' :: Int -> IO ()) 5) :: Int -> IO ()) 4 :: IO Int (of course it is an example in fact it will be not only Int etc.) Personally I'd prefere in-haskell solution as: - Rts API used by Gtk2Hs is 'semi-public' - It is GHC-specific (?) but I'm not sure if my solution is safe. Regards

5 5

Uncontrolled Concurrency, isn't that concept now thread-bare?
by Casey Hawthorne 17 Aug '09

17 Aug '09

-- Regards, Casey

1 0

DDC compiler and effects; better than Haskell? (was Re: [Haskell-cafe] unsafeDestructiveAssign?)
by Peter Verswyvelen 17 Aug '09

17 Aug '09

I knew about DDC for a while but never bothered to look at it deeply since it was so young, and at first sight it just did what ML did (silently allowing side effects). But when looking again at it, it seems it actually does some very clever things to allow side effects and still be safe, a bit what one does explicitly with Haskell's ST and IO monads, but in DDC, the compiler seems to analyze where side effects happen and automatically annotates/enrich the types (with things like region, closure and effect information) to indicate this. The example given by DDC is that in Haskell, you need two versions of each higher order function if you really want your library to be reuseable, e.g. you need map and mapM, but in DDC you just need one function, map, which also is written in a pure style. See e.g. http://www.haskell.org/haskellwiki/DDC/EffectSystem I kind of agree with the DDC authors here; in Haskell as soon as a function has a side effect, and you want to pass that function to a pure higher order function, you're stuck, you need to pick the monadic version of the higher order function, if it exists. So Haskell doesn't really solve the modularity problem, you need two versions of each higher order function really, and you need to carefully plan ahead of time if you want to write in a monadic or pure style, and it also splits my brain mentally ("side effects are ***evil***. But hang on, how can I e.g. do a depth first search efficiently purely functional? Damn, it seems I can't! Let's switch back to C#/C++!!! Nooooo ;-) This seems to make Haskell not a good language for doing things like extreme programming where code evolves, unless you have some insanely clever refactoring tool ready that can convert pure into monadic functions and vice versa. Is it true that - as in DDC - side effects can be analyzed by the compiler (in the same sense that say, strictness is analyzed), freeing the library and user from writing/picking monadic versions??? If so, would this indeed solve the modularity/reusablity issue? I feel you can't have your cake and eat it here, so there must be catch? :-) Thanks for sharing any thoughts on this, Peter Verswyvelen

28 72

Blank definition list in haddock
by Maurício CA 16 Aug '09

16 Aug '09

I read in haddock documentation that we write definition lists like this: -- [@something@] Definition of something. However, using that structure to document many itens, I get a blank list of definitions, like you can see in this section ('Macros') of the documentation for a package of mine: http://hackage.haskell.org/packages/archive/bindings-common/0.2.2/doc/html/… However, as can be seen in the source code, there are many definitions inside 'Macros' section. http://hackage.haskell.org/packages/archive/bindings-common/0.2.2/doc/html/… Did I used those definitons the wrong way? Thanks, Maurício

2 2

ANN: Haddock version 2.5.0
by David Waern 16 Aug '09

16 Aug '09

-------------------------------------------- -- Haddock 2.5.0 -------------------------------------------- A new version of Haddock, the Haskell documentation tool, is out! If you're using GHC 6.10.2 and Haddock 2.4.2, you should be able to upgrade to this version without any problem. If you're using something else, you should re-install any documentation that you want to link to after upgrading. Please use the bug tracker to submit bug reports or feature requests. -------------------------------------------- -- Changes in version 2.5.0 -------------------------------------------- * Drop support for GHC 6.8.* * Add support for GHC 6.10.3 and 6.10.4 * Revert to the old multi-page index for large packages (#106) * Show GADT records in the generated documentation * Create the output directory if it doesn't exist (#104) * Use the native codegen instead of compiling via C for TH modules * Add --use-unicode flag for displaying prettier versions of common symbols * Mutiple verbosity levels: remove --verbose and add --verbosity=n * Simpler versioning of .haddock files To avoid slow search, Haddock switches from the searchable index to the old multi-page index for large packages (containing over 150 items). This, and support for GADT records in the generated documentation was implemented by Isaac Dupree as part of his Summer of Code project. The --use-unicode flag was contributed by George Porges. -------------------------------------------- -- Links -------------------------------------------- Homepage: http://www.haskell.org/haddock Hackage page: http://hackage.haskell.org/package/haddock-2.5.0 Bugtracker and wiki: http://trac.haskell.org/haddock Mailing list: haddock(a)projects.haskell.org Code repository: http://code.haskell.org/haddock -------------------------------------------- -- Contributors -------------------------------------------- The following people contributed patches to this release: Isaac Dupree Ian Lynagh Simon Marlow Simon Peyton-Jones George Porges David Waern -------------------------------------------- -- Future Plans -------------------------------------------- Here are the top priority tickets right now: * Cross-package documentation (#24) * Good warning messages when encountering unexpected Haddock comments (#94) * Comments on instance declarations (#29) Isaac Dupree has been working on the first item as part of his SoC project and it is near completion. If you have any input on what we should prioritize, add yourself to the CC list of the ticket(s) that you are interested in. -------------------------------------------- -- Get Involved -------------------------------------------- We would be very happy to get more contributors. To get involved, start by grabbing the code: http://code.haskell.org/haddock Then take a look at the bug and feature tracker for things to work on: http://trac.haskell.org/haddock

3 4

qsort
by Peter Verswyvelen 16 Aug '09

16 Aug '09

I was reading the introduction at http://www.haskell.org/haskellwiki/Introduction where the typical Haskell version of qsort is given qsort [] = [] qsort (x:xs) = qsort (filter<http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:filter> (< x) xs) ++<http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:.> [x] ++<http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:.>qsort (filter<http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:filter> (>=<http://haskell.org/ghc/docs/latest/html/libraries/base/Prelude.html#v:>=>x ) xs which is then compared to the inplace C version, showing off how much shorter the Haskell version is. However, the page also has a link to a "semi-direct" translation of the C version, which then brings the user to all kinds of confusing threads and texts, like *"**Unfortunately none of the above "real" quicksorts seems to compile as given, when copy/pasted into ghci. Can someone fix? The "parallel" quicksort gave error "unknown package concurrent" when I ran make in quicksort/gransim. Has anyone got a functioning "real" quicksort that works on copy/paste? The program below is working very very slowly. It's probably slowsort... :o)"* * * Furthermore the inplace versions of qsort in Haskell are IMO less readable than the C version. I'm not sure but if I would be a beginner I might get confused by this. It is often claimed that compiler technology will make it possible to compile high level code into efficient low level code that is almost as efficient as the C or asm routines. How does this apply to qsort today? Cheers, Peter Verswyvelen

3 2

GSoC profiling project to be wrapped up
by Patai Gergely 16 Aug '09

16 Aug '09

Hi everyone, I finally uploaded the profiling tools to Hackage. The package names are hp2any-{core,graph,manager}. The first two should be possible to install right away, while the manager needs Gtk2Hs. A bit more on the project and this update at <http://just-bottom.blogspot.com>. Gergely -- http://www.fastmail.fm - IMAP accessible web-mail

3 4

why does the binary library require so much memory?
by Jeremy Shaw 16 Aug '09

16 Aug '09

Hello, Using encode/decode from Binary seems to permamently increase my memory consumption by 60x fold. I am wonder if I am doing something wrong, or if this is an issue with Binary. If I run the following program, it uses sensible amounts of memory (1MB) (note that the bin and list' thunks won't actully be evaluated): import Data.Binary main :: IO () main = let list = [1..1000000] :: [Int] bin = encode list list' = decode bin :: [Int] in putStrLn (show . length $ takeWhile (< 10000000) list) >> getLine >> return () /tmp $ ghc --make -O2 Bin.hs -o bin /tmp $ ./bin +RTS -s /tmp/bin +RTS -s 1000000 68,308,156 bytes allocated in the heap 6,700 bytes copied during GC 18,032 bytes maximum residency (1 sample(s)) 22,476 bytes maximum slop 1 MB total memory in use (0 MB lost due to fragmentation) Generation 0: 130 collections, 0 parallel, 0.00s, 0.00s elapsed Generation 1: 1 collections, 0 parallel, 0.00s, 0.00s elapsed INIT time 0.00s ( 0.00s elapsed) MUT time 0.05s ( 0.92s elapsed) GC time 0.00s ( 0.00s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 0.05s ( 0.92s elapsed) %GC time 0.0% (0.1% elapsed) Alloc rate 1,313,542,603 bytes per MUT second Productivity 100.0% of total user, 5.7% of total elapsed According to top: VIRT RSS SHR 3880 1548 804 Now, if I change *list* in the last line to *list'* so that the encode/decode stuff actually happens: /tmp $ ./bin +RTS -s /tmp/bin +RTS -s 1000000 617,573,932 bytes allocated in the heap 262,281,412 bytes copied during GC 20,035,672 bytes maximum residency (10 sample(s)) 2,187,296 bytes maximum slop 63 MB total memory in use (0 MB lost due to fragmentation) Generation 0: 1151 collections, 0 parallel, 0.47s, 0.48s elapsed Generation 1: 10 collections, 0 parallel, 0.36s, 0.40s elapsed INIT time 0.00s ( 0.00s elapsed) MUT time 0.47s ( 20.32s elapsed) GC time 0.84s ( 0.88s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 1.30s ( 21.19s elapsed) %GC time 64.1% (4.1% elapsed) Alloc rate 1,319,520,653 bytes per MUT second Productivity 35.9% of total user, 2.2% of total elapsed And top reports: VIRT RSS SHR 67368 64m 896 63 times as much total memory in use. And, this is while the program is waiting around at 'getLine' after it is 'done' with the data. I am using GHC 6.10.4 on GNU/Linux. Thanks! - jeremy

6 14

Re: [Haskell-cafe] Elerea/GLFW Tetris
by Patai Gergely 15 Aug '09

15 Aug '09

> Here is my first real program in Haskell. How come you started out with playing around with FRP libraries right away? It's a rather peculiar choice, I'd say. > In fact, I'm not fully responsible because it's just an adapted > version of a Tetris Creighton Hogg had written for Reactive/GLUT. > As the first version, it's a very simple game (no levels, no > points ...) but it's playable ! It's an interesting exercise, and quite a nice job from someone who considers themselves a beginner. One thing I don't really understand is why you packed up those applicative combinators in a SignalMonad, i.e. the reason behind flat and sf_sa. You have much more freedom in using them as they are, since they can appear inside any expression. For instance, you could just say the following in the let declaration: sfall = (uncurry . fall) <$> randomBehavior seed sid = pure id Or even better, since both sfall and sid are created by pure combinators, you don't even need to name them if they are used only once anyway: autumn = ifte metronome ((uncurry . fall) <$> randomBehavior seed) (pure id) Another thing, which is really a matter of taste, is that you seem to like point-free style acrobatics. I don't think it's always the best choice, especially if you are to share code with others, since most people grok code with explicit parameters easier than magic involving flip and const and (un)curry and the like, except for the obvious cases of composing a chain of operations, where dropping arguments feels quite natural. For instance, the definition of f_a looks problematic to me because of these concerns. Gergely -- http://www.fastmail.fm - Same, same, but different...

2 1

Re: [Haskell-cafe] Improving event management in elerea
by Patai Gergely 14 Aug '09

14 Aug '09

> can you explain, please ? I can't feel it when I play. Well, the paddle moves very fast that way, and its speed depends on the refresh rate. While the refresh rate is set in this program, it's not a good idea to depend on it in any way. Transfer functions provide access to the frame time, so you can adjust the speed to be independent of it. > or using some rounding as I did in my first implementation ? It's good if that works. However, I wouldn't depend on that either, since you might have to struggle with edge cases, and you also rely on the sizes being related to each other in various ways instead of choosing them freely. In my opinion, the best solution in this case would be a clamped integral, which would also make it unnecessary to check for the edge of the field in the condition (note that I make use of the Num instances of signals to take care of the lifting): integralClamped v0 vmin vmax s = transfer v0 accum s where accum dt v v0 = max vmin $ min vmax $ v0+v*realToFrac dt playerX <- integralClamped playerX0 (-fieldW) (fieldW-playerW) (ifte lpress (-1) 0 + ifte rpress 1 0) >From these, integralClamped and ifte might also be good candidates for inclusion in the library. Gergely -- http://www.fastmail.fm - Choose from over 50 domains or use your own

2 1

Re: Adding an ignore function to Control.Monad
by Jeff Wheeler 14 Aug '09

14 Aug '09

On Fri, Jul 10, 2009 at 10:10 PM, Don Stewart<dons(a)galois.com> wrote: >> ## Control.Monad.void m a -> m () >> Don Stewart >> Iavor Diatchki For whatever it's worth, I prefer void as well, for the exact reason Don said. Indeed, 'ignore' indicates to me that the argument won't even be evaluated: it'll be ignored, and skipped. But it is, and only part --- the result --- is ignored. What about 'void' with functors? Jeff Wheeler

8 7

Quickcheck for common typeclass laws
by Job Vranish 14 Aug '09

14 Aug '09

Is there a hackage package that contains quickcheck properties for the laws of common typeclasses? (Functor, Monad, Num, Ord, Eq, Applicative, etc...) so that one could quickly check (har har) that their new instances satisfy the appropriate laws? It would be very nice to have a isValidMonad (undefined :: MyNewMonadType) function. If one does not exist, I may just have to make one. - Job

3 2

Re: [Haskell-cafe] Improving event management in elerea
by Patai Gergely 14 Aug '09

14 Aug '09

> or > > event :: a -> Signal Bool -> (a -> a) -> SignalMonad (Signal a) > event v0 b f = accumIf v0 f =<< return b > > ? That's not a good idea, because it doesn't take time into consideration, so you'd jump a huge amount in every frame. What I had in mind is something like this: ifte :: Signal Bool -> Signal a -> Signal a -> Signal a ifte sc st sf = (\c t f -> if c then t else f) <$> sc <*> st <*> sf And then: playerX <- integral playerX0 ( ifte (lpress &&@ (playerX >@ pure (-fieldW))) (-1) 0 + ifte (rpress &&@ (playerX <@ pure (fieldW-playerW))) (1) 0 ) This won't be perfect, since the paddle can get a bit beyond the edge of the field. This can be prevented by using some kind of clamped integral, for instance, which you can again define in terms of transfer, just like the plain integral. Also, note that mixing bind and return is redundant, since "f =<< return b" is equivalent to "f b". Gergely -- http://www.fastmail.fm - Choose from over 50 domains or use your own

2 1

Cleaner networking API - network-fancy
by Taru Karttunen 14 Aug '09

14 Aug '09

Hello network-fancy offers a cleaner API to networking facilities in Haskell. It supports high-level operations on tcp, udp and unix sockets. I would like some feedback on the API http://hackage.haskell.org/packages/archive/network-fancy/0.1.4/doc/html/Ne… In particular: * Does the type of the server function in dgramServer make sense? or would (packet -> Address -> (packet -> IO ()) -> IO ()) be better? * Does the StringLike class make sense? * Any other suggestions? - Taru Karttunen

6 7

Re: [Haskell-cafe] Improving event management in elerea
by Patai Gergely 14 Aug '09

14 Aug '09

Hello Jean, If I got you right, you basically want to have a signal that changes its value by a predetermined transform function whenever there is an edge detected on a bool signal. In that case, it would be easier to define it in terms of transfer: accumIf :: a -> (a -> a) -> Signal Bool -> SignalMonad (Signal a) accumIf v0 f b = transfer v0 g b where g _dt c x0 = if c then f x0 else x0 event :: a -> Signal Bool -> (a -> a) -> SignalMonad (Signal a) event v0 b f = accumIf v0 f =<< edge b I even factored out the edge functionality. Of course you also have to pass playerX0 to this function as is, without the pure wrapping. Also, your flat function is practically equivalent to (return . pure), why did you define it using transfer? Another thing to note is that you might want to define playerX as an integral of a velocity derived from lpress and rpress, so you wouldn't need to press and release the buttons repeatedly, and the speed would be the same regardless of sampling rate, since integral takes the time step into account. > but I still can't answer my first one (couldn't this function > -or its improvement- be part of the library ?) Sure, anything is possible. Elerea is a new library, and it deliberately exposes only some low-level constructs. In particular transfer, which basically lets you fall back on pure state transformer functions. My idea was that as more and more code is written in it, we can extract recurring patterns and add them to the library. But at the moment it is not clear what the useful patterns are, and I'd rather not start guessing and littering the library with useless combinators in advance. For instance, the accumIf function is a conditional version of stateful, and it might be generally useful. Whether it's the best name, that's another question. Gergely -- http://www.fastmail.fm - The professional email service

2 1

containers and maps
by John Lato 14 Aug '09

14 Aug '09

Hello, The recent discussion regarding One Container Class To Rule Them All got me to thinking about container classes and map functions. ListLike (which is really a pretty nice package, and I would like to see more people use it) provides two map functions, a regular map with type > map :: (item -> item') -> full -> full' and also rigidMap: > rigidMap :: (item -> item) -> full -> full I think the utility of rigidMap is clear for anyone who's tried to solve the container class problem. Anyway, I had the idea of taking both maps out of ListLike entirely, and replace them with this: > class (ListLike full item, ListLike full' item') => Map full item full' item' where > map :: (item -> item') -> full -> full' Wouldn't this be better? I see the following benefits: -instances for polymorphic types like List are trivial -instances for monomorphic types (e.g. ByteString) can use the native map implementation. -Instances for types with class restrictions on the elements (e.g. UVector) can also be written. On the downside, the class context is much longer, but you'd only need to write the whole thing when you're actually using map, and then it'll include the ListLike instance automatically. Obviously this isn't so much one container class to rule them all as it is a set of classes that all work together, but as long as it's sensible that's fine with me. Thoughts? John Lato

3 6

Hack on the Delve core, with Delve and Haskell
by spoon 14 Aug '09

14 Aug '09

Delve is a new programming language intended to bring the benefits of static type checking and functional programming to object-oriented design and development. It is an impure, eager language (Yes I can hear the groans of woe and cries for sanity already!) Currently Delve supports: Higher-order functions/first class functions Anonymous functions Lexical closures First class continuations Tail-call optimization A meta-object model (classes are objects) S-Expression based syntax. Embedded Haskell expressions within Delve. What it doesn't have: Lots and lots! Basically what I have is an de-sugared, untyped core language. An analogy could be made with Haskell core files. I'm going to be working on the type system for next little while (I have a stack of paper and a pen right here!). Once that is implemented we'll see where to go. Please see the TUTORIAL file included in the source for a brief outlook on Delve's syntax, semantics and planned type system. However! If you're looking for a new project, and especially if you are an undergraduate, then I think Delve would be a good choice for these reasons: It's written in a hybrid of Haskell and itself. It's currently undergoing active development (by me and some pals). You're not going to be lonely! It's quite powerful already, without too many lines of code (it's now just about 5.5KLOC - it's no goliath! ) It's a programming language: name a compiler which isn't a cool piece of tech! Ok, maybe you can but still, it's a chance to work on something non-trivial and interesting. Quite honestly, I'm a bit of a fool - I am a math undergrad! So don't you feel foolish about getting involved if you're not a professorial chap! If you feel like it, get involved in the design, and push me the patches :) It does require lots of love though! It was all hacked out rather quickly :) Executables which Delve provides: edc -- The Elgin Delve Compiler The Elgin Delve Compiler currently supports two backends - the first to a bytecode format for execution on edvm, and the second is to a Haskell source code representation of Delve bytecode. This allows Haskell to be embedded within Delve, for the express purpose of extending and building edvm. edc is written in Haskell (GHC). edvm -- The Elgin Delve Virtual Machine The Elgin Delve Virtual Machine executes Delve bytecode files (.dcode format). Since part of the VM is actually driven by Delve bytecode, edvm can be considered a hybrid of Delve and Haskell (again GHC). Delve continues the grand tradition of naming compilers after Scottish Cities (no, Elgin does not have a university). Delve is released under the terms of the GNU GPLv3. For more information on Delve, check my blog at http://killersmurf.blogspot.com/ and the Delve repository at http://github.com/elginer/Delve/ -- John

2 2

Improving MPTC usability when fundeps aren't appropriate?
by Daniel Peebles 13 Aug '09

13 Aug '09

Hi all, I've been playing with multiparameter typeclasses recently and have written a few "uncallable methods" in the process. For example, in class Moo a b where moo :: a -> a the moo function is effectively impossible to call (no amount of type annotations can tell the compiler what you intended b to be there). Some might suggest adding an a -> b functional dependency, but in some cases that is not appropriate, as there are multiple possible instances. Another solution would be to artificially force moo to take a "dummy" b so that the compiler can figure out which instance you meant. That's what I've been doing in the mean time, but wouldn't it be simpler and less hackish to add a some form of "instance annotation", like a type annotation, that would make it possible to specify what instance you wanted when it's ambiguous? I'm not sure what syntax might be appropriate here, but it could also be seen as "opening" a particular instance, so something "open"-like might be good. I don't know whether this has already been discussed much, but I was unable to find anything that seemed relevant (beyond discussing relationships between parametrized modules and typeclasses) but I wanted to know if anyone had any opinion on adding such a feature to (a future revision of) Haskell? I know people are generally reluctant to add new syntax elements to a language, but considering the lack of such a feature and the impossibility of writing such a thing in the language itself, it seems like it'd be useful to add to the language itself. Thanks, Dan

4 4

Space for commentaries on hackage
by Maurício CA 13 Aug '09

13 Aug '09

It would be nice to have a place for anonimous comments below each page of a hackage package, maybe with a cabal option to enable/disable that for a particular package. Authors of packages with few users may want that as a way to get first impressions on their work they would otherwise not get. (At least, I am, so I thought maybe others probably would.) Best, Maurício

4 5

Re: DDC compiler and effects; better than Haskell? (was Re: [Haskell-cafe] unsafeDestructiveAssign?)
by Gregory Michael Travis 13 Aug '09

13 Aug '09

"John A. De Goes" <john(a)n-brain.net> sed: > Hmmm, bad example. Assume memory instead. That said, reordering/ > parallelization of *certain combinations of* writes/reads to > independent files under whole program analysis is no less safe than > sequential writes/reads. It just "feels" less safe, but the one thing > that will screw both up is interference from outside programs. This reminds me of something I've heard of: the commutative monad. I might have seen the phrase in some presentation by Simon Peyton-Jones. I took it to mean some sort of monad that sequenced computations, but was also capable of reordering them according to rules specified by the implementer of the monad. Thus, you could re-order operations on separate files, because they can't possible interfere with each other. This strikes me as an important idea, something that would allow you to incrementally optimize while keeping safety. For example, let's say you implement a complex distributed system, using a single distributed state monad to manage global state. This would be very slow, since you would no doubt have to have a central node controlling the order of all side-effects. But this node could re-group and re-distributed the side-effects. This would be done by using the type system to carefully separate effects that couldn't interfere. I'm not expressing this as well as I'd like. From the programmer's perspective, though, it could have a nice property: you start with a slow, but trivial state monad. Then you add rules and clauses that indicate when two effects can have their order switched; all the while, the meaning of the program is unchanged. This is not unlike nodes distributed database that have to receive updates from other nodes and figure out how to apply all the updates in a coherent order, or throw an exception if it cannot.

1 0

Improving event management in elerea
by jean legrand 13 Aug '09

13 Aug '09

Hi Haskellers, I've written a new version of the breakout elerea-example where mouse is replaced by LEFT and RIGHT keys http://hpaste.org:80/fastcgi/hpaste.fcgi/view?id=8159 and I have two questions. 1) my event function (line 79) returns a new signal and takes 3 arguments : an initial signal and a Bool signal which triggers when to apply the transform function given as a third argument. The body of the event function uses two calls to the sampler function. Is it possible to write this body with a unique call to sampler ? 2) this event function is used to link a keypress with a transformation of the position of the player. It is thus called two times (lines 91 and 94), one for each one of the two keys LEFT and RIGHT. Thanks to the ability to compose a new Bool signal from other ones, it is possible to define a guard for the transform function during the calls to event (lines 92 and 95 : the incrementation (decrementation) is only doable when the player abscissa is less than 0.6 (more than -0.8)). Nevertheless, during the game, I noticed some discrepancy with this ideal description : try to go to an extreme side (several hits of the LEFT key for instance until the player hits the left side) then go back in the opposite direction before hitting the opposite side (three hits of the RIGHT key for instance) then the first key pressing corresponding to the opposite of the opposite direction (i.e the initial LEFT direction) has no effect. Do you understand why ? Thanks

1 1

Re: Thinking about what's missing in our library coverage
by Alexander Dunlap 13 Aug '09

13 Aug '09

On Mon, Aug 3, 2009 at 4:44 PM, Don Stewart<dons(a)galois.com> wrote: > > Following Simon M's advice, I look over the typical "batteries" > categories, using Python as input: > > http://docs.python.org/library/index.html > > The following things were missing from the current Platform. There are many. > How would you identify the top, say, 5 libs to add? > > -- Don > > > * String support > o pcre regexes [pcre-light] [regex-pcre] — what’s our best regex lib? For something like this, it seems like all of the regex libs probably have pros and cons. It would be good if we could identify what these are and create a library that was the "best of all worlds" instead of just picking one and going with it. > o unicode text [text] [text-icu] — packed, unicode text This is essential, although I don't know if it is stable enough for the platform (?). > * text > o pandoc — markdown, reStructuredText, HTML, LaTeX, ConTeXt, Docbook, OpenDocument, ODT, RTF, MediaWiki, groff No. Pandoc is too actively developed to go into the HP. It's also much more of an end-user application than a "standard library" - it's applications are not general enough to be included in the standard distribution. > * math and numerics > o blas — BLAS > o cmath — C math functions > o dimensional — physical dimensions > o fftw > o mersenne-random — fast randoms The interfaces here should be unified more to create a general Haskell numerical library, IMO. > * compression > o bzip2 > o zip > o tar Definitely. > * file formats > o config parser This would be quite useful. > * crypto > o hmac, md5, sha, hashing Yes. > * systems > o getopt > o logging > o termio > o editline > o mmap All of these, at some point. > * Internet > o network-bytestring > o ssl > o json > o feed (rss, atom) > o mime > o base64 et al > o uuencode > o cgi > o fastcgi > o urls > o ftp, http, imap, smtp clients > o uuid > o url parsing > o http server > o xml-rpc Interface unification would help. Especially network-bytestring seems to be too ad-hoc for me - it would probably be better to put ByteString support into the regular Network library.... > * Internationalization > o gettext > o locale > o i18n Yes, although again, maturity? > * Development > o hscolour Yes. My main concern is with libraries like attoparsec and network-bytestring - these libraries seem to be somewhat ad-hoc conversion of traditional libraries to use ByteStrings. We should come up with a cleaner, more elegant way of dealing with the String/Text/Strict ByteString/Lazy ByteSTring gap, as most libraries that apply to one of those types also apply to the other two, as the first two and last two especially and more generally all four essentially represent the same thing. We shouldn't bless libraries that don't have a good way of applying equally to these three. A possible solution could be a standardized package-common, package-string, package-text, package-bytestring, package-lazybytestring naming convention, or a Category.Module, Category.Module.String, Category.Module.ByteString.Strict, Category.Module.ByteString.Lazy, Category.Module.Text convention. We could also work something up with type classes. I just don't like how a lot of libraries implement support for various string types just based on need rather than creating a clean, comprehensive interface. Alex

14 25

IFL 2009: Final Call for Papers and Participation
by IFL 2009 13 Aug '09

13 Aug '09

1 0

unsafeDestructiveAssign?
by Job Vranish 13 Aug '09

13 Aug '09

Does anybody know if there is some unsafe IO function that would let me do destructive assignment? Something like: a = 5 main = do veryUnsafeAndYouShouldNeverEveryCallThisFunction_DestructiveAssign a 8 print a > 8 and yes I am in fact insane... I'm also looking for a way to make actual copies of data. so I could do something like this: a = Node 5 [Node 2 [], Node 5 [a]] main = do b <- makeCopy a veryUnsafeAndYouShouldNeverEveryCallThisFunction_DestructiveAssign b (Node 0 []) -- 'a' is unchanged It would be even more fantastic, if the copy function was lazy. I think the traverse function might actually make a copy, but I would be happier with something more general (doesn't require membership in traversable), and more explicit (was actually designed for making real copies). Any ideas? Thanks, - Job

10 13

Parallel Symbolic Computing Research Post
by Trinder, Philip W 13 Aug '09

13 Aug '09

The next generation of HPC platform will provide teraflop performance from 10^5 or more cores. A major challenge is to develop the programming models and software infrastructures to effectively exploit these architectures. In the HPC-GAP project (High Performance Computational Algebra and Discrete Mathematics EPSRC EP/G055181) we aim to address this challenge for the GAP Group Algebra package. You will join a team of four researchers in an ambitious programme to adapt the GAP computational algebra system to take advantage of modern high performance computers. You will collaborate with other HPC-GAP members at Aberdeen and St Andrews and Edinburgh Universities. You will take part in and publish research using the software you develop. You will have excellent parallel system engineering expertise, a degree in computer science, an appropriate PhD or equivalent, and good teamwork skills. Desirable criteria include functional language experience e.g. Haskell, a track record of academic publications, experience preparing research grant applications, and experience with a range of software technologies. You will start on 1 September 2009 and continue until the end of the grant in August 2013. Full details at www.jobs.ac.uk/jobs/SP072/Research_Associate_-_Parallel_Symbolic_Computi ng/ -------------------------------------------- Phil Trinder School of Mathematical and Computer Sciences Heriot-Watt University Edinburgh, EH14 4AS E: P.W.Trinder(a)hw.ac.uk T: +44 (0)131 451 3435 F: +44 (0)131 451 3327 I: www.macs.hw.ac.uk/~trinder -- Heriot-Watt University is a Scottish charity registered under charity number SC000278.

1 0

Re: unsafeDestructiveAssign?
by John Lato 13 Aug '09

13 Aug '09

> From: John Meacham <john(a)repetae.net> > Subject: Re: [Haskell-cafe] unsafeDestructiveAssign? > On Wed, Aug 12, 2009 at 06:48:33PM +0100, John Lato wrote: > > On Wed, Aug 12, 2009 at 2:39 PM, Derek Elkins<derek.a.elkins(a)gmail.com> wrote: > > > > > > (To Alberto as well.) > > > > > > Unsurprisingly, Lennart stated the real issue, but I'll re-emphasize > > > it. Â As much trouble as such a profound violation of purity would > > > cause, it's not the biggest problem. Â If that were all, you could > > > easily write a C/assembly function that would do what was desired. > > > The real problem is that there isn't necessarily any "data chunk" at > > > all, i.e. there may not be anything to mutate. > > > > > > > Lennart is right of course, but wouldn't his example just be a > > specific case of my argument? That is, the compiler decided to > > evaluate the data at compile time by replacing it with the primitive > > value and inlining it? It seems to me that in the absence of putting > > some scope or sequencing upon the mutating function, there's no way > > for such an unsafeMutate* to have any defined meaning in Haskell. And > > once you have provided either scope or evaluation order, it would be > > equivalent to just using a monad (although not necessarily IO). > > > The inherent problem is that 'heap locations' are not first class values in > haskell. There is no way to refer to 'the location holding a variable', > not so much because they don't exist, but because it is just > inexpressible in haskell. for instance, Thanks for this clear explanation. The concept of an unsafeDestructiveAssign function really caught my attention because it seemed inexpressible. This makes perfect sense, including an explanation for mutable data in IO (because IORef, Ptr, and the like make a "data location" a first class value). I like to have a solid foundation for my nonsense. Cheers, John

1 0

DDC compiler and effects
by oleg＠okmij.org 13 Aug '09

13 Aug '09

Combining non-strict evaluation and even laziness (non-strictness plus sharing) with effects is of course possible. That is the topic of the ICFP09 paper of Sebastian Fischer et al., which describes the combination of laziness with non-determinism. The ideas of the paper have been implemented in a Hackage package and in the embedded probabilistic DSL Hansei. In the presence of effects, call-by-name is no longer observationally equivalent to call-by-need: one has to be explicit what is shared. Curry's call-time-choice seems a good choice: variables always denote values rather than computations and can be shared at will (of the run-time system). The language is still non-strict, and computations whose results are not demanded are not evaluated and none of their effects are performed. Since any computable effect can be modeled by delimited control, call-by-name shift/reset calculi provide general treatment of effects and non-strictness. Call-by-name delimited control calculi have been developed by Herbelin (POPL08). A different call-by-name shift/reset calculus (containing call-by-value calculus as a proper subset) is described in http://okmij.org/ftp/Computation/Continuations.html#cbn-shift The latter, cbn-xi, calculus includes effect sub-typing, which is common in effect calculi. A call-by-name function whose argument type is effectful can always be applied to a pure term. A pure term can be regarded as potentially having any effect. On the other hand, a function whose argument type is pure can only be applied to a pure term. The cbn-xi calculus also supports strict functions. Their argument type is always a pure type and they can be applied to terms regardless of their effect, because the effect will occur before the application. Pure functions thus provide a measure of effect-polymorphism. The cbn-xi and the other CBN calculi with delimited control are deterministic. The best application for the cbn-xi calculus I could find was in linguistics. The calculus was used to represent various effects in natural language: quantification, binding, raised and in-situ wh-questions. Importantly, several effects -- several question words, anaphora with quantification, superiority -- could be represented. One may view ML and Haskell as occupying two ends of the extreme. ML assumes any computation to be effectful and every function to have side effects. Therefore, an ML compiler cannot do optimizations like reordering (even apply commutative laws where exists), unless it can examine the source code and prove that computations to reorder are effect-free. That obviously all but precludes separate compilation; the only aggressive optimizing ML compiler, MLton, is a whole-program compiler. Haskell, on the other hand, assumes every expression pure. Lots algebraic properties become available and can be exploited, by compilers and people. Alas, that precludes any effects. Hence monads were introduced, bringing back control dependencies disguised as a data dependency. Monadic language forms a restrictive subset of Haskell (for example, we can't use monadic expressions in guards, `if' and `case' statements). In the monadic sublanguage, Haskell swings to another extreme and assumes, like ML, that everything is impure. Thus in an expression, do x <- e1 y <- e2 ... the two binding cannot be commuted, even if e1 and e2 are both 'return'. If the compiler sees the source code of e1 and e2 and is sufficiently smart to apply monadic laws, the compiler can determine the two bindings can be reordered. However, if e1 and e2 are defined in a separate module, I don't think that any existing compiler would even think about reordering. Hopefully a system like DDC will find the middle ground.

1 0

Working around file locking in Windows
by Patai Gergely 13 Aug '09

13 Aug '09

Hello all, I'm trying to make the hp2any suite to be fully functional under Windows, but I'm running into permission errors when I try to read the heap profile that's still being written by its producer. Is there a way to solve this problem without turning to the Win32 interface and having to write platform specific code? Gergely -- http://www.fastmail.fm - One of many happy users: http://www.fastmail.fm/docs/quotes.html

2 1

unsafeDestructiveAssign?
by John Lato 13 Aug '09

13 Aug '09

Hi Job, I don't think this hypothetical function could exist; you may as well call it "notEverSafeOhTheHumanity" and be done with it. Since Haskell provides no guarantees about when (if ever) any given function/data will be evaluated, you would need some mechanism to tell the compiler that a data chunk has a certain value at one time and a different value at another. The language provides this in the IO (and ST) monads. So the function would need to live within IO, and you don't gain anything. If you try to take it outside of IO, with e.g. unsafePerformIO, then the compiler will no longer treat it like IO and the result is free to be evaluated whenever, so you're back where you started. Also, keep in mind that purity is a language requirement in Haskell and such a function really would "break everything". Specifically, you would get differing output depending on the exact transformations performed by the compiler, which in general would be difficult to predict in advance, probably not the same between different compiler versions, changed by compiler flags and phases of the moon, etc. I have an example in a darcs repo somewhere... Cheers, John > From: Job Vranish <jvranish(a)gmail.com> > Subject: Re: [Haskell-cafe] unsafeDestructiveAssign? > > Ga! Before to many people start flooding me responses of "This is really > dumb idea don't do it!" I would like to clarify that for the most part > IKnowWhatI'mDoing(TM) > > I am well aware of the usual ST/IORefs as the usual solutions to data > mutability in haskell. > I very very much understand purity, and why it is a good thing, and why we > should try to stay away from IO and ST as much as possible. > I am very much away that even if I had such a function that it will probably > break everything. > I am not just trying to make things run faster. > > What I am trying to do is hyper unusual and I really do need an > unsafeHorribleThings to do it. > > - Job

4 4

ANNOUNCE: GLFW-0.4.1
by Paul L 13 Aug '09

13 Aug '09

I'm glad to announce a new version of GLFW, 0.4.1, has been uploaded to HackageDB. Notable changes include: * workaround for a FFI bug that affects GHC < 6.10 on 64-bit machines. * fix for the compilation problem on OS X for GHC > 6.10.1 * compatibility fix to work with both OpenGL 2.3.0.0 and older versions. * choice of a "dynamic" flag to link with dynamic GLFW C library instead. * a number of other fixes, cleanups and improvements. Many thanks goes to Brian Lewis, Sönke Hahn, and other people who sent in bug reports, patches, and suggestions. If you have any problem with this new version, you can either reply this email, or send to my other account (paul at thev.net) -- Regards, Paul Liu Yale Haskell Group http://www.haskell.org/yale

1 0