July 2011 - Haskell-Cafe

QuickCheck Questions
by Mark Spezzano 02 Aug '11

02 Aug '11

Hi all, I would appreciate it if someone can point me in the right direction with the following problem. I'm deliberately implementing a naive Queues packages that uses finite lists as the underlying representation. I've already read through Hughes' paper and the article in The Fun of Programming, but I'm still having some difficulties. Specifically: 1. I have a newtype Queue a = Queue [a] and I want to generate Queues of random Integers that are also of random size. How do I do this in QuickCheck? I guess that I need to write a generator and then make my "Queue a" concrete type an instance of Arbitrary? How? 2. If I wanted to specify/constrain the ranges of random Integers generated, how would I do this? 3. If I wanted to specify/constrain the Queue sizes how would I do this? On a separate issue, I also see that QuickCheck 2 has some features not discussed anywhere. For example "Coarbitrary" and "shrink" are a bit of a mystery to me. Any code examples for any of the above questions would help greatly. I've been stuck on this problem for hours. :) Cheers, Mark

4 4

State of play with Haskell-Cocoa (Objective-C) bindings?
by Luke Evans 01 Aug '11

01 Aug '11

I'm planning to start an Objective-C/Cocoa project and would like to write it in Haskell as much as possible. Of course, I can contrive to split the project into app logic (Haskell) and UI (Objective-C) with some sort of minimal interface between them; possibly just plain old C FFI. However, I would like an interface that's as 'automatic' as possible - one that preferably means that I don't have to spend a lot of time maintaining a somewhat heavy-weight special interface layer as I grow my code on both sides of the divide. Preferably the suture line is as far over on the Objective-C side as possible, so that I can write pretty much everything in Haskell. Now, I see a couple of references to some options: - HOC seems very close to what I'm looking for, but the project looks pretty 'dormant'. - I see some mention of an Objective-C FFI, but am uncertain if this is in any current build of GHC. Are there any other options up anyone's sleeves? Anybody working on something interesting I could play with? Until recently, I was concerned about being able to use GC on the Objective-C side, but with Apple's new ARC memory management model, that's no longer an issue. Most Haskell-ObjC bindings that already exist are surely designed for Retain-Release, which I assume is not disrupted by ARC as this is just RR at runtime. -- Luke

3 2

Unbelievable parallel speedup
by John D. Ramsdell 01 Aug '11

01 Aug '11

I've enjoyed reading Simon Marlow's new tutorial on parallel and concurrent programming, and learned some surprisingly basic tricks. I didn't know about the '-s' runtime option for printing statistics. I decided to compute speedups for a program I wrote just as Simon did, after running the program on an unloaded machine with four processors. When I did, I found the speedup on two processors was 2.4, on three it was 3.2, and on four it was 4.4! Am I living in a dream world? I ran the test nine more times, and here is a table of the speedups. 2.35975 3.42595 4.39351 1.57458 2.18623 2.94045 1.83232 2.77858 3.41629 1.58011 2.37084 2.94913 2.36678 3.63694 4.42066 1.58199 2.29053 2.95165 1.57656 2.34844 2.94683 1.58143 2.3242 2.95098 2.36703 3.36802 4.41918 1.58341 2.30123 2.93933 That last line looks pretty reasonable to me, and is what I expected. Let's look at a table of the elapse times. 415.67 176.15 121.33 94.61 277.52 176.25 126.94 94.38 321.37 175.39 115.66 94.07 277.72 175.76 117.14 94.17 415.63 175.61 114.28 94.02 277.75 175.57 121.26 94.10 277.68 176.13 118.24 94.23 277.51 175.48 119.40 94.04 415.58 175.57 123.39 94.04 277.62 175.33 120.64 94.45 Notice that the elapse times for two and four processors is pretty consistent, and the one for three processors is a little inconsistent, but the times for the single processor case are all over the map. Can anyone explain all this variance? I have enclosed the raw output from the runs and the script that was run ten times to produce the output. John

5 4

A language that runs on the JVM or .NET has the advantage of Oracle & Microsoft making those layers more parallelizable.
by KC 31 Jul '11

31 Jul '11

Are there plans a foot (or under fingers) to make a version of Haskell that runs on the JVM? -- -- Regards, KC

9 9

Re: [Haskell-cafe] XCode Dependency for HP on Mac
by Tom Murphy 31 Jul '11

31 Jul '11

On 7/30/11, Mark Lentczner <mark(a)glyphic.com> wrote: > Hiho - I'm the maintainer of the Mac installer for HP. I thought I'd > chime in a bit: > An expert :) > On Mac OS X, "developer tools" is essentially synonymous with "Xcode". > That is, to get the set of standard utilities needed for development > on compiled executables (notably the "binutils"), you install Xcode. > True, it also includes the IDE called Xcode, but the vast bulk [...] Remember everyone: install just the system tools and dev tools (only haskell required parts), and your install is 1 or 2 GB instead of 11GB. > As several have pointed out, you can download Xcode for free. It turns out this is true. It's very hard to find the dl link to an XCode that doesn't require Lion, but it actually is there. > (I haven't bought a new Air... > yet... but perhaps someone can check to see if the Xcode installer is > one the SSD volume already?) > It doesn't, and it's not on the USB restore disk either. > It is conceivably possible to build and distribute some of those > tools, but not the whole bundle. But the difficulty of getting such a > build just right, and all the pieces in the right place, seems absurd > to attempt to recreate when Apple has done it, and gives it away for > free. Apple's versions of bintools also includes many extensions extra > options for the OS X environment (like supporting multi-arch binaries) > Finally, there is also licensing questions regarding the parts > supplied by the OS vendor (headers, stub libs, debug libs, etc....) > So in response to the question "is there a way to install the HP without XCode?" the answer is pretty much no. Ok. It's a shame, but thanks for the insight! Thanks, Tom

1 0

Re: [Haskell-cafe] [Haskell-beginners] No instance for (Show a)
by Mark Spezzano 31 Jul '11

31 Jul '11

Hi, You might need a class constraint. instance (Show a) => Show (Stack a) where This basically lets Haskell know that if your "a" type is Showable then "Stack a" is also Showable. Let me know if this works. Cheers, Mark Spezzano On 31/07/2011, at 6:49 PM, Ovidiu Deac wrote: > For some reason ghc complains about not being able to call show on an > Integer (?!?!?) > > Please enlighten me! > > ovidiu > > This is the hspec: > it "shows one element" > ( show (push 1 EmptyStack) ≡ "Stack(1)") > > ...this is the code: > > data Stack a = > EmptyStack | > StackEntry a (Stack a) > deriving(Eq) > > > instance Show (Stack a) where > show s = > "Stack(" ⊕ (showImpl s) ⊕ ")" > where > showImpl EmptyStack = "" > showImpl (StackEntry x _) = show x > > ...and this is the error: > > src/Stack.hs:12:22: > No instance for (Show a) > arising from a use of `showImpl' > In the first argument of `(++)', namely `(showImpl s)' > In the second argument of `(++)', namely `(showImpl s) ++ ")"' > In the expression: "Stack(" ++ (showImpl s) ++ ")" > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners

2 1

Properties for Foldable
by Conal Elliott 29 Jul '11

29 Jul '11

Is there a collection of laws associated with the Foldable class? Or for Traversable? - Conal

5 6

Function returning the type of its argument.
by Grigory Sarnitskiy 29 Jul '11

29 Jul '11

It is not possible in Haskell, moreover it seems to be too alien to Haskell. Nevertheless, is there an extension which would allow to write a function that returns the type of its argument?

3 2

Contract opportunity with Biosimilarity LLC
by Greg Meredith 29 Jul '11

29 Jul '11

Dear Haskellians, No desire to spam, but some folks on this list might find this of interest. Best wishes, --greg Biosimilarity LLC is looking for a the next Merlin! We need an artiste with a certain taste and technical instinct that have attracted them to next generation functional programming languages and other high magic. We need a technologist who can make the demons and dragons of web front ends do their bidding while making sound architectural and platform choices. Naturally, comfort with the Open Source ecosystem from git and GitHub to mvn and/or sbt to Jenkins is a given. For such a candidate we don't have to talk about familiarity with Scala or Haskell or ML or JavaScript or Clojure because they eat languages for breakfast and graphics libraries for lunch. The initial engagement is for a limited contract. However, if things go well, who knows what adventures await? The innovations and market potential of the project are guaranteed to keep any sorcerer fascinated. And, you'll get a chance to work with a team of like-minded magicians with long track records of delivering landmark software. While Biosimilarity is a Seattle-based company, telecommuting is definitely an option for the right candidate. If you feel like this might be you, please contact me directly at this email or via the number provided below. Sending along a CV in advance of a more personable communication is likely to be the most effective protocol, but we're always open to creativity. An online portfolio of web projects could also be an advantage, but again raw creativity and can-do carry the day here. -- L.G. Meredith Managing Partner Biosimilarity LLC 1219 NW 83rd St Seattle, WA 98117 +1 206.650.3740 http://biosimilarity.blogspot.com

3 2

Re: [Haskell-cafe] compare iteratee with python's yield
by oleg＠okmij.org 28 Jul '11

28 Jul '11

Your question is insightful. The posted answers are excellent. I merely wish to illustrate one, already made, point on a concrete example. The complete code is in the file http://okmij.org/ftp/Haskell/Iteratee/IterDemo.hs The file implements a series of progressively more complex examples -- from wc to grep, -- stressing compositionality. The whole program is assembled from independent building blocks; as our task changes, we replace one building block with another. The building blocks, iteratees, may be stateful. We never have to worry about writing out the whole state of the program and properly initializing it. The overall state is implicitly composed from the state of each building block; each iteratee manages its own state without leaking it. The particular example to illustrate the state encapsulation is grep1_word > grep1_word word fname = > let search = IterateeM.dropWhile (/= word) >> IterateeM.head > runI' = runI . en_handle (\_ -> "not found:" ++ word) in > print =<< run =<< enum_file fname > (runI =<< en_lines > ((runI' =<< en_words search) > `en_pair` (count_i `en_pair` en_last))) which implements "grep -w -n -m 1 <word> <filename>". It searches for the first occurrence of the given word in the file and returns the line of that occurrence and the line number. (The example also illustrates exception handling: The exception is raised by Iteratee.head when IterateeM.dropWhile dropped the whole stream while looking for the given word.) A few comments: en_lines is the enumeratee, transforming a stream of characters into a stream of lines; en_words is the enumeratee that transforms the stream of lines to the stream of words. The stateful iteratee count_i counts the elements in any stream; en_last, the analogue of List.last, returns the last seen element. The combinator en_pair pairs two iteratees to run in parallel, processing the same stream chunk-by-chunk. The processing stops as soon as one of the iteratees in the pair stopped. That behavior does the trick: "en_words search" stops when the word is found. The whole pair is stopped too. The other component of the pair, (count_i `en_pair` en_last), will receive EOF and tell us the line and the line count they have last seen. I guess the example can be written in Python-like style as follows (simplifying and assuming that the file is already parsed into lines): counter = 0 for line in file_lines: counter = counter + 1 if contains line word: print counter print line break Suppose we wish to change our example to print not only the found line, but a few lines before it (the option "-B" of grep). We have to modify our Python-like code: -- add a piece of state to keep the context lines, and initialize it -- add code to update the state as we read lines -- add the finalization code, to convert the state to the desired result The code will look like the following (### mark the changes): counter = 0 lines_seen = [] ### for line in file_lines: counter = counter + 1 accumulate lines_seen line ### if contains line word: print counter print (finalize lines_seen) ### break In contrast, to modify the iteratee code for the new task, we make the _single_ change: replace en_last with (en_lastN 5) (for 5 lines of context). It should be stressed that the Python code has to be changed in three *distinct, disconnected places*. New state has to be defined and initialized, before the loop. The state has to be updated, somewhere in the loop. The state has to be finalized, in the loop termination part. When changing code, it is easy to overlook the needed changes. For example, it is easier to accumulate the context lines in reverse order. When printing the lines, we should not forget to reverse them. When changes are disconnected, it is hard to reason and test for them. With so many other things going on, it is hard to write a proper test (for example, when testing the context accumulation we don't care about word matching; we should test the accumulation in isolation of whatever else we are doing in the iteration). The iteratee en_lastN deals only with the context accumulation aspect: > -- Return N last received elements > -- The acc below is the list of N last elements in the reverse > -- order > en_lastN :: Monad m => Int -> Iteratee el m [el] > en_lastN n = ie_cont $ step [] > where > step acc (Chunk []) = ie_contM (step acc) > step acc (Chunk ls) = ie_contM (step $! Prelude.take n $ reverse ls ++ acc) > step acc stream = ie_doneM (reverse acc) stream The initialization of the state, the accumulation and the finalization are all in the same place. The en_lastN iteratee does not care of counting, searching, or whatever else is going on. In fact, the iteratee is pure and deals with arbitrary elements (not necessarily lines). We can test it using Quickcheck or HUnit. No IO is needed for the test. Thus in the iteratee style, the overall state of the program becomes distributed, across iteratees that encapsulate and manage only their own, small portion of the program state. The code IterDemo.hs shows other examples, including emulating generators (aka, unfold_stream, or the `while loop'), to build the stream of intermediate results of an iteratee. An iteratee in question does not even suspect that it is being used `incrementally', seduced to reveal the intermediate results. Thank you for the inspiring question.

1 0