00:00:00 --- log: started haskell/02.01.13
00:11:29 --- quit: dmiles (Read error: 104 (Connection reset by peer))
00:32:49 --- join: dmiles (~alife@sense-sea-MegaSub-2-56.oz.net) joined #haskell
02:07:07 --- quit: aleksi (Remote closed the connection)
02:28:57 --- join: teek (teemu@k72.viikki.hoasnet.fi) joined #haskell
04:10:00 --- join: shapr (~user@p-c2fbab4f.easy.inet.fi) joined #haskell
04:11:57 <shapr> bon giornio!
04:40:51 <shapr> has anyone here used QuickCheck?
04:46:12 --- quit: teek ("Coffee break")
06:08:03 * shapr bangs head on QuickCheck
06:14:59 <xbill> heh
06:26:30 <shapr> does anybody understand QuickCheck?
06:43:09 <xbill> I've never gotten it to work.
06:43:40 <shapr> I just noticed that the manual isn't really the manul
06:43:51 <shapr> the ICFP paper about QuickCheck is the manual
06:43:54 <xbill> heh, well, so much for docs
06:44:16 <shapr> yah, I think I might be able to figure it out from the paper
06:44:56 <shapr> hey xbill, you were showing me how you can convert takeUntil into separate functions, take and until
06:45:28 <shapr> and you've shown me code that does the same kind of thing where you take one function and 'break it down' into separate useful pieces
06:45:32 <shapr> is there a name for that?
06:46:04 <xbill> hrm, not sure, "factoring"?
06:46:22 <Heffalump> refactoring
06:46:26 <Heffalump> oh, sorry, slicing.
06:47:00 <shapr> well, whatever name you give it, that's the viewpoint that QuickCheck takes to test functions
06:47:58 <xbill> slicing sounds better, no C++ associations
06:48:40 <shapr> I'd argue that slicing is already used in Icon, and now in Python
06:48:48 <shapr> factoring makes more sense to me
06:48:54 <shapr> or something like decomposing
06:49:24 <xbill> "hierarchical decomposition"
06:49:36 <shapr> oh, I like it ;)
06:49:53 * shapr adopts it
06:51:13 <Heffalump> decomposition is probably most appropriate for splitting takeUntil into take and until
06:51:30 <shapr> yah, but there's some kind of mathematical provability deal here as well
06:51:50 <shapr> it's like mathemathical proofs as applied to haskell
06:51:50 <Heffalump> sorry?
06:52:04 <Heffalump> oh, yes, but I don't see how "hierarchical" is appropriate
06:52:12 <shapr> sadly, my experience in this area is very limited
06:52:16 <shapr> and so is my vocabulary
06:52:25 <shapr> I know what I'm trying to say, I just don't have the right words
06:52:43 <shapr> xbill showed me this cool trick that I also saw somewhere the Thompson book
06:53:04 <shapr> he threw down some code that showed how to stick take and until together to get takeUntil
06:53:21 <shapr> and then he threw down the equivalent code to break takeUntil apart into take and until
06:54:03 * Heffalump isn't quite sure what you mean. Is this to do with deforestation?
06:54:18 * shapr bangs his head against functional programming in general
06:54:19 * shapr laughs
06:54:24 <shapr> no, not deforestation :)
06:54:50 <shapr> ok
06:54:53 <shapr> lemme try it again
06:55:05 <shapr> I've heard that Haskell programs are close enough to mathemathical equations
06:55:19 <shapr> that I can do a proof from them, with very little work.
06:55:20 <shapr> is that true?
06:55:36 <Heffalump> pretty much, yes
06:55:47 <shapr> ok
06:56:45 <shapr> for functions that can be built out of two other functions, it seems that I can quickly prove that
06:56:56 <shapr> by showing how to put those two together to make the more complex function
06:57:07 <shapr> and how to take apart the complex function to make the two simpler functions
06:57:14 <Heffalump> right
06:57:21 <shapr> can you say "derive take and until from takeUntil" ?
06:57:24 <shapr> something like that?
06:57:26 <shapr> is it called deriving?
06:57:30 <Heffalump> possibly
06:57:39 <shapr> ok :)
06:57:42 <shapr> fair enough
07:01:40 <shapr> ack
07:02:03 <shapr> Heffalump: you ever used QuickCheck?
07:02:47 <Heffalump> nope, sorry
07:02:53 * shapr grumbles
07:03:00 <Heffalump> I've heard talks about it from John Hughes but I can't remember any of them :-)
07:03:04 <shapr> heh
07:03:05 <shapr> oh wel
07:03:21 <shapr> I can't even get the first examples from the ICFP paper to work
07:03:29 <Heffalump> ah :-(
07:03:40 <shapr> No instance for (Show (IO ()))
07:03:40 <shapr> arising from use of `print' at <No locn>
07:03:40 <shapr> In a 'do' expression pattern binding: print it
07:03:56 <shapr> I should be getting "OK: passed 100 tests"
07:04:30 <Heffalump> try removing the print completely
07:04:41 <Heffalump> if you can find where it is
07:06:05 <shapr> oh
07:06:07 <shapr> I get it
07:06:36 <shapr> no, I don't.
07:06:59 <shapr> foo
07:07:44 <shapr> here's the entire module:
07:07:50 <shapr> module Test
07:07:50 <shapr> where
07:07:50 <shapr> import QuickCheck
07:07:50 <shapr> prop_RevUnit x = 
07:07:50 <shapr>     reverse [x] == [x]
07:07:51 <shapr> prop_RevApp xs ys = 
07:07:53 <shapr>     reverse (xs++ys) == reverse ys ++ reverse xs
07:07:55 <shapr> prop_RevRev xs = 
07:07:57 <shapr>     reverse (reverse xs) == xs
07:08:05 <shapr> so I hit C-c C-l to dump it into my ghci session
07:08:15 <shapr> then I run "quickCheck prop_RevRev"
07:08:39 <Heffalump> and it does that?
07:08:41 <shapr> No instance for (Show (IO ()))
07:08:41 <shapr> arising from use of `print' at <No locn>
07:08:41 <shapr> In a 'do' expression pattern binding: print it
07:08:41 <shapr> <interactive>:1:
07:08:41 <shapr>     Ambiguous type variable(s) `a' in the constraint `Arbitrary a'
07:08:41 <shapr>     arising from use of `quickCheck' at <interactive>:1
07:08:43 <shapr>     In the definition of `it': quickCheck prop_RevRev
07:08:45 <shapr> <interactive>:1:
07:08:47 <shapr>     Ambiguous type variable(s) `a' in the constraint `Show a'
07:08:49 <shapr>     arising from use of `quickCheck' at <interactive>:1
07:08:51 <Heffalump> hmm.
07:08:51 <shapr>     In the definition of `it': quickCheck prop_RevRev
07:08:53 <shapr> <interactive>:1:
07:08:55 <shapr>     Ambiguous type variable(s) `a' in the constraint `Eq a'
07:08:56 <Heffalump> how big is the QuickCheck module?
07:08:57 <shapr>     arising from use of `prop_RevRev' at <interactive>:1
07:08:59 <shapr>     In the first argument of `quickCheck', namely `prop_RevRev'
07:09:01 <shapr> whoops sorry
07:09:11 <shapr> http://www.cs.chalmers.se/~rjmh/QuickCheck/QuickCheck.hs
07:09:12 <shapr> very small
07:10:12 <xbill> heh
07:10:49 <Heffalump> you have an interesting definition of "very small".
07:11:08 <shapr> though I admit, Haskell works like those wide-angle rear-view mirrors on cars
07:11:18 <shapr> er, I really do think that's small.
07:11:50 <shapr> "objects written in Haskell may be larger than you think they are"
07:12:00 <shapr> or something like that.. what do the mirrors really say?
07:12:48 <shapr> Heffalump: maybe it's my daily exposure to Java
07:13:13 <Heffalump> :-)
07:13:28 <Heffalump> umm. are you sure what you pasted above is the correct way to use quickCheck?
07:14:14 <shapr> no, but the manual gives zero examples, so I'm reading the ICFP paper that's linked next to the manual:
07:14:16 <shapr> http://www.cs.chalmers.se/~rjmh/QuickCheck/
07:14:33 <Heffalump> hmm.
07:14:51 <shapr> and that's the example from page 2 of the ICFP paper.
07:15:57 <shapr> aha
07:16:08 <shapr> maybe it's the part that says "we load them into the Hugs interpreter"
07:16:32 <Heffalump> it fails in hugs too
07:16:34 <shapr> oh
07:17:29 <Heffalump> ahh.
07:17:32 <shapr> ??
07:17:38 <Heffalump> you left out that where types = xs::[Int] bit
07:18:06 <shapr> !
07:18:14 * shapr bangs his head against his inability to read
07:18:14 <Heffalump> that's a trick to tell QuickCheck what type of test data to use
07:18:16 <shapr> doh!
07:18:23 <shapr> uh, thanks :)
07:18:26 * shapr blushes
07:18:38 <Heffalump> all the complaints you were getting were cos it didn't have any idea what test data to generate
07:18:40 <Heffalump> no problem :-)
07:18:49 * Heffalump gets back to writing some really basic C
07:18:53 <shapr> heh
07:18:55 <shapr> sounds like fun
07:19:04 <Heffalump> I can do Haskell but I can't do C socket programming...
07:19:16 <shapr> I think that's normal.
07:19:31 <Vutra_> nope
07:19:33 <Vutra_> hehe
07:20:14 <shapr> well, now it works fine.
07:20:18 <shapr> much thanks Heffalump!
07:20:22 <xbill> I can do Haskell and C
07:20:33 <shapr> xbill: you're multilingual.
07:20:34 <xbill> I did a chatserver in Haskell
07:20:42 <shapr> cool! is the source online?
07:20:51 <xbill> ... and mercury and ocaml and lisp and scheme and prolog and...
07:20:56 <shapr> oh
07:20:57 <shapr> wow
07:21:06 <xbill> shapr: it's bitrotted but it's there somewhere
07:21:23 * shapr looks
07:21:32 <xbill> shapr: http://holomorphy.com/~wli/chat/
07:21:54 * Heffalump can do C too, I just have never done any socket programming
07:21:59 <Heffalump> I can't do Haskell socket programming either :-)
07:22:19 <shapr> xbill: nifty
07:23:52 <xbill> shapr: not the cleanest stuff in the world
07:24:09 <shapr> good code == working code
07:24:34 <xbill> shapr: sorry, doesn't work either
07:24:53 <shapr> :)
07:25:07 <shapr> well, I'll fix it after I finish fixing Imap.hs
07:25:09 <xbill> shapr: http://holomorphy.com/~wli/server/ <-- the real attempt to update it
07:25:27 <shapr> I'd like to turn Imap.hs into a general purpose Imaplib for Haskell
07:25:58 <shapr> hrm, I need a publically accessible cvs tree somewhere.
07:27:11 <Heffalump> Imap.hs?
07:27:15 <shapr> I wonder if it's rude to create a sourceforge project for semi-personal but publically accessible code
07:27:27 <shapr> Heffalump: cool chunk of code xbill wrote
07:27:37 <shapr> he gave me permission to clean it up and release it to the world
07:27:46 <shapr> I just have to finish cleaning it up.
07:28:29 <Heffalump> why do you need it to be publically accessible? so people can download from it?
07:28:37 <shapr> yup
07:28:43 <shapr> and so other people can change it
07:28:56 <shapr> I wish there were some way to do wiki-like code repositories
07:29:07 <xbill> shapr: not at all, maybe a "Haskell library project" would be good?
07:29:08 <shapr> publically accessible cvs trees appears to be the best option
07:29:17 <shapr> excellent idea
07:29:33 <Heffalump> you'd want to be able to protect certain branches
07:29:43 <shapr> true
07:30:06 <shapr> I think xbill's idea of a Haskell library project on sourceforge is good.
07:31:33 <Heffalump> did the proposed Haskell library hierarchy stuff ever reach a conclusion?
07:31:44 <shapr> I have no idea.
07:31:53 <shapr> when did it happen?
07:32:12 <shapr> I've only been in the community/language since september or so
07:32:14 <Heffalump> few months back on the Haskell list
07:32:28 <Heffalump> I think Simon Marlow was coordinating it
07:37:31 <shapr> This project's purpose is to provide a central web site and cvs tree to collect and maintain useful bits of Haskell code for the Haskell community.
07:38:40 <shapr> hrm, I only get to choose one license
07:39:52 <Heffalump> sorry?
07:40:05 <xbill> shapr: might as well go LGPL
07:40:09 <shapr> yah, I agree
07:42:22 <shapr> er, how do I say "outside of the standard libraries"
07:42:56 <shapr> The Haskell Libraries project is here to furnish one central location to find and submit and maintain unofficial libraries written in Haskell.
07:43:04 <shapr> better word than "unofficial"?
07:43:27 <shapr> non-standard
07:43:41 <shapr> accessories?
07:44:36 <shapr> extra?
07:44:43 <shapr> ahha
07:44:46 <shapr> user-submitted
07:50:36 <xbill> who knows?
07:52:15 --- join: Vutr__ (~ss@212.169.153.171) joined #haskell
07:54:29 --- nick: Vutr__ -> Vutral
08:09:48 --- quit: Vutra_ (Read error: 110 (Connection timed out))
09:54:53 --- quit: kepler (Remote closed the connection)
10:40:27 --- join: jcore (~jcore@ca-glendora1a-10.stmnca.adelphia.net) joined #haskell
10:56:18 --- join: kepler (~kepler@adsl-81-164-221.asm.bellsouth.net) joined #haskell
11:54:09 --- quit: kepler (Remote closed the connection)
11:56:28 --- quit: shapr (Remote closed the connection)
13:39:13 --- join: Vutra_ (~ss@port-212.169.145.32.flat4all.de) joined #haskell
13:41:23 --- join: Vutr__ (~ss@212.169.153.28) joined #haskell
13:49:37 --- quit: Vutra_ (Read error: 60 (Operation timed out))
13:57:05 --- quit: Vutral (Read error: 110 (Connection timed out))
13:59:59 --- quit: Vutr__ (Read error: 110 (Connection timed out))
14:06:26 --- join: smklsmkl (~sami@glubimox.yok.utu.fi) joined #haskell
14:06:31 --- quit: smkl (Read error: 54 (Connection reset by peer))
14:07:32 --- nick: smklsmkl -> smkl
15:12:48 --- join: kepler (~kepler@adsl-81-164-221.asm.bellsouth.net) joined #haskell
16:06:31 --- quit: dennisb (Read error: 113 (No route to host))
19:56:35 --- quit: kepler (Remote closed the connection)
21:16:45 --- quit: xbill ("Leaving")
21:25:40 --- join: xbill (wli@DOMINIA.MIT.EDU) joined #haskell
22:09:40 --- quit: jcore (Remote closed the connection)
23:59:59 --- log: ended haskell/02.01.13