00:00:00 --- log: started haskell/02.03.18
00:02:54 --- quit: smkl (Remote closed the connection)
00:03:18 --- join: smkl (~sami@glubimox.yok.utu.fi) joined #haskell
00:43:39 --- join: shapr (~user@195.156.199.166) joined #haskell
01:20:36 --- join: dmiles (~alife@sense-sea-MegaSub-2-56.oz.net) joined #haskell
01:24:02 <shapr> hello dmiles 
02:10:26 --- join: work_den (~dennis@lancre.cs.chalmers.se) joined #haskell
02:11:14 <work_den> this channel was logged somewhere I remember, but where do I find the logs?
02:13:42 <Heffalump> http://tunes.org/~nef/logs/haskell/
02:13:55 <Heffalump> (it's in the topic)
02:14:12 <work_den> ooh, sorry :-)
02:32:58 * Yurik is back (gone 02:49:34)
02:38:40 --- quit: clausen ("send all money to /dev/clausen")
02:51:00 <shapr> hi work_den, what's up?
03:42:23 --- join: Yurik_ (~yrashk@gw.telcos.net.ua) joined #haskell
03:42:31 <shapr> hi Yurik
03:42:59 --- quit: Yurik (Read error: 104 (Connection reset by peer))
03:44:26 <work_den> shapr: hi, not much. working, working and working :-)
03:44:49 <Yurik_> shapr: hi
03:45:29 <shapr> same here, lots of work, no haskell
03:45:43 <shapr> though I'm tempted to learn HaXml for this SMIL viewer :)
03:45:58 <work_den> SMIL?
03:47:55 <shapr> Synchronized Multimedia Integration Language
03:48:24 <shapr> it lets you stick audio, images, animations (both vector and bitmap), text and more all into one xml file.
03:48:28 <shapr> it's relatively spiffy.
03:48:43 <work_den> i've never heard of it
03:49:59 <shapr> it's somewhat new, up until recently, the only existing player has been real.com's realaudio player
04:03:54 * Igloo_ almost actually uses records before discovering you have to give a name to every field
04:05:50 --- nick: Yurik_ -> Yurik
04:12:58 <shapr> Igloo_: eh?
04:13:18 <shapr> sounds like variable access in an object
04:16:54 <Igloo_> I wanted to do something like   data Foo = Foo {x :: Int, String, y :: Char, Int} but you aren't allowed (and the syntax would break with type variables if you were), so now I have data Foo = Foo Int String Char Int and have defined x and y myself
04:56:14 --- quit: Igloo_ (carter.openprojects.net irc.openprojects.net)
04:56:14 --- quit: Heffalump (carter.openprojects.net irc.openprojects.net)
04:56:14 --- quit: shapr (carter.openprojects.net irc.openprojects.net)
05:09:34 --- join: shapr (~user@195.156.199.166) joined #haskell
05:09:34 --- join: Igloo_ (~igloo@c93.keble.ox.ac.uk) joined #haskell
05:09:34 --- join: Heffalump (ganesh@munchkin.comlab.ox.ac.uk) joined #haskell
05:12:17 --- quit: shapr (carter.openprojects.net irc.openprojects.net)
05:12:17 --- quit: Heffalump (carter.openprojects.net irc.openprojects.net)
05:12:17 --- quit: Igloo_ (carter.openprojects.net irc.openprojects.net)
05:13:20 --- join: shapr (~user@195.156.199.166) joined #haskell
05:13:20 --- join: Igloo_ (~igloo@c93.keble.ox.ac.uk) joined #haskell
05:13:20 --- join: Heffalump (ganesh@munchkin.comlab.ox.ac.uk) joined #haskell
05:13:35 --- quit: Heffalump (carter.openprojects.net irc.openprojects.net)
05:13:35 --- quit: Igloo_ (carter.openprojects.net irc.openprojects.net)
05:13:58 --- join: Heffalump (ganesh@munchkin.comlab.ox.ac.uk) joined #haskell
05:13:58 --- join: Igloo_ (~igloo@c93.keble.ox.ac.uk) joined #haskell
05:34:34 --- quit: work_den ("X-Chat!")
05:51:30 --- quit: Jiriki (Read error: 104 (Connection reset by peer))
05:55:49 --- join: Jiriki (sjh@Rockcliffe92.tbaytel.net) joined #haskell
06:07:35 * Yurik is away: smoke
06:13:38 * Yurik is back (gone 00:05:51)
06:32:34 <shapr> I really like functional programming
06:32:38 <shapr> it's quite spiffy
06:47:11 --- join: Verbed (verbed@24.70.83.145) joined #haskell
07:20:03 <shapr> hi Verbed 
07:20:48 <Verbed> Hello
07:20:53 <shapr> what's up?
07:21:09 <Verbed> Nothing interesting
07:21:23 <shapr> written any nifty code lately?
07:21:58 <Verbed> Just some elementary sound synthesis, and it certainly wasn't in Haskell :)
07:22:22 <shapr> which lang?
07:22:39 <Verbed> C
07:22:45 <shapr> oh
07:22:52 * Yurik started uniting fdscript (scheme) w/ Erlang by implementing DTYPE :)
07:23:04 <shapr> nifty code is a good thing.
07:23:07 <shapr> in any language.
07:23:17 * Yurik found a lack of documentation on DTYPE :-(
07:23:32 <shapr> I forgot what DTYPE is...
07:23:49 <Verbed> Either of you visited any good sites on abstract algebra lately?
07:24:25 <Verbed> I wish I could find an author that exhibited a passion the subject, a deep philosophical understanding.
07:24:54 <Yurik> shapr: DTYPE is data representation for FramerD object database
07:25:06 <Verbed> ( ... passion _about _ the ... )
07:54:43 --- quit: shapr ("restarting X window server ... java.awt.Robot + Xinerama = trapped mouse")
08:30:25 --- join: Yurik_ (~yrashk@gw.telcos.net.ua) joined #haskell
08:30:58 --- quit: Yurik (Read error: 104 (Connection reset by peer))
08:31:28 --- quit: Yurik_ (Client Quit)
08:31:41 --- join: Yurik_ (~yrashk@gw.telcos.net.ua) joined #haskell
08:34:58 --- nick: Yurik_ -> Yurik
08:58:28 * Yurik is away: to wif e
08:58:38 --- quit: Yurik (Read error: 104 (Connection reset by peer))
09:04:50 --- join: Suburban (~user9852@213.58.35.11) joined #haskell
09:04:56 <Suburban> hi there
09:05:41 --- join: samx (~sam@dyn-Q-129.yhteys.mtv3.fi) joined #haskell
09:06:24 <Suburban> can anyone help me?
09:06:37 <Heffalump> depends what your problem is
09:07:34 <Suburban> i want to make a function to divide even and odd numbers from a list into two lists
09:08:34 <Suburban> i know it is simple, but i am just starting
09:08:59 <Heffalump> look at the partition function in the Prelude
09:09:24 <Suburban> the name of the function is partition?
09:09:28 <Heffalump> yep
09:09:36 <Heffalump> well, you can use that to do what you want
09:09:44 <Heffalump> you'll need to define something to check whether a number is even or odd
09:09:48 <Suburban> let me check
09:10:01 <Suburban> and how do i do that?
09:10:11 <Igloo_> Like the cunningly named odd and even you mean?
09:10:34 <Igloo_> :-)
09:11:23 <Suburban> those are functions two?
09:11:30 <Igloo_> Yup
09:11:43 <Heffalump> oh, ok :-)
09:12:33 <Suburban> :-)
09:12:39 <Suburban> I checked it :-)
09:13:09 <Suburban> so I' ll have to use even and odd
09:13:26 <Suburban> but how should I define the function to separate them?
09:13:55 <Heffalump> look at partition
09:15:41 <Suburban> i can't find partition in prelude!
09:16:28 <Igloo_> Are you sure it isn't in List?
09:17:20 <Heffalump> so it is
09:17:20 <Suburban> I'll check
09:17:33 * Heffalump could have sworn it was common enough to be in Prelude
09:19:04 <Suburban> ok, i found it in List
09:19:11 <Suburban> i'll try it now
09:20:02 <Verbed> Why do I keep thinking of Woozles?
09:20:58 <Suburban> It seems a bit difficult! How should I put in in the function? to tell to separate?
09:22:11 <Heffalump> just pass it as a parameter
09:24:36 <Suburban> ok
09:26:37 <Suburban> i can't read List.hs!
09:28:11 <Igloo_> Oh cool, the new hat stuff has been released
09:28:22 * Igloo_ should see if still segfaults on my code some time
09:29:49 <Suburban> could anyone of you give me the code, as an example, for me to practice then?
09:31:51 <Verbed> , partition         -- :: (a -> Bool) -> [a] -> ([a], [a])
09:32:01 <Verbed> From my List.lhs ( ghc )
09:32:10 <Verbed> Now, I really don't know Haskell
09:32:21 <Verbed> But logically, it appears to take 2 arguments
09:32:39 <Verbed> The first being a decision function
09:33:03 <Verbed> It should return True when the value satisfies some property
09:33:09 <Verbed> And False, for another.
09:33:21 <Suburban> yes, seems to
09:33:25 <Verbed> You should also pass partition the list you want it to partition
09:33:43 <Verbed> And it evaluates to a tuple ( pair, whatever ) containing the 2 lists you want.
09:33:43 <Suburban> i'm confused here
09:34:13 <Suburban> a tuple of two lists?
09:34:24 <Verbed> Yes.
09:35:38 <Verbed> For example, let's assume there exists a function that returns True if a supplied number is even, and False otherwise.  We'l call it even.
09:36:11 <Suburban> ok
09:36:12 <Verbed> And you also have a list bound to numlist, [1, 2, 3, 4]
09:36:20 <Suburban> yes
09:36:37 <Verbed> If you were to execute the following code:  partition even numlist
09:36:48 <Verbed> ( Or however you call functions in Haskell )
09:36:58 <Verbed> It would evaluate to a pair of lists
09:37:04 <Suburban> so I have a list of numbers and a function that verifies if a given number is even
09:37:11 <Verbed> Exactly
09:37:37 <Suburban> I'll try this
09:37:50 <Verbed> And I guess you could extract the two lists from the tuple using pattern matching.
09:42:24 <Suburban> I guess so
09:42:26 <Suburban> thanks
09:42:37 <Suburban> I tried this . it's working
09:43:02 <Suburban> are there any defined functions for pattern-matching?
09:44:38 <Heffalump> pattern matching is part of the language
09:44:55 <Heffalump> unless you mean matching with regular expressions, in which case there's a Regex module somewhere around (not part of the core distribution)
09:45:58 <Suburban> for instance, if I wanted to separate to a different partition after a specific sign in the string?
09:47:03 <Heffalump> then you need something more complicated than partition
09:47:24 <Suburban> can't you help me?
09:47:56 <Heffalump> yes, but you're not being clear about what you want
09:49:43 <Suburban> I want to separate into two partitions the first and second parts of a string. these parts are separated by the + sign
09:51:19 <Heffalump> have a look at takeWhile and dropWhile then
09:51:23 --- join: shapr (~user@p-c2fbab7e.easy.inet.fi) joined #haskell
09:51:23 <Heffalump> or splitAt, if that exists
09:51:58 <Heffalump> oh, no, not splitAt
09:52:07 <shapr> ?
09:52:09 <Heffalump> span or break, possibly
09:54:39 <Suburban> I'll have to go now
09:54:51 <Suburban> Thank you for your help
09:54:58 <Suburban> in deed
09:55:08 <Verbed> You're welcome
09:56:19 <Suburban> see you
09:57:49 --- part: Suburban left #haskell
10:02:06 --- quit: Verbed ("Client Exiting")
10:12:50 * shapr finds hunit.sourceforge.net
10:12:51 <shapr> nifty
10:32:58 --- join: ChoJin (~ask@cha213245038031.chello.fr) joined #haskell
10:33:35 <shapr> hi ChoJin 
10:33:39 <ChoJin> hi
10:33:46 <shapr> what's up?
10:34:11 <ChoJin> well, I have a lot of work :)
10:34:17 <ChoJin> hence I'm tired :)
10:34:29 <shapr> I understand
10:34:37 <ChoJin> and hence I cannot play so much with haskell :)
10:34:50 <shapr> aw :(
10:41:39 <shapr> how do I get to the Socket module from inside hugs?
10:42:39 <Heffalump> is it implemented for hugs?
10:42:45 <shapr> I don't know...
10:42:55 <shapr> I just grep'ed the hugs package, it's not in there.. hmm
10:43:38 <shapr> well then
10:51:56 --- quit: samx (Read error: 110 (Connection timed out))
10:53:22 --- join: samx (~sam@dyn-M-209.yhteys.mtv3.fi) joined #haskell
10:53:28 <shapr> hi samx 
10:54:23 <samx> hi
10:54:55 <shapr> what's up?
10:55:19 <shapr> are you an experienced Haskeller?
10:56:28 <samx> no, not at all. i really don't use haskell at all
10:56:43 <shapr> oh
10:56:47 <shapr> do you want to learn it?
10:57:58 <samx> i'm familiar with most of the concepts in it, and i'm programmed a bit with it, but at it's current state, i don't think it's for me..
10:58:11 <shapr> oh, ok
11:01:34 <samx> i'm more drawn towards languages that compile to decent speed code. currently mostly using ocaml. but i like many of the things in haskell, but think that at least with the current implementations, it's not useful for my purposes. and i'm interested in how those concepts could be used in a real-time/high-performance language
11:02:42 <shapr> Python is "decent speed" to me, so Haskell is also just fine :)
11:02:58 <samx> to me, python is a snail :-)
11:04:51 --- quit: dmiles (Connection timed out)
11:13:30 --- quit: shapr ("f00")
11:56:38 --- join: shapr (~user@p-c2fbab7e.easy.inet.fi) joined #haskell
11:57:29 <shapr> f00
13:22:00 --- quit: samx (Read error: 110 (Connection timed out))
13:34:00 * shapr considers spending a bit of time trying to build ghc
13:34:26 <Heffalump> did you get openGL working in the end? I forget
13:34:37 <shapr> no, it had that xlib dependency, remember?
13:34:48 <shapr> that's actually what I want to try, building with OpenGL
13:35:15 <Heffalump> hmm, right
13:43:32 --- join: JustRay (~ray@folsom.officedepot.com) joined #haskell
13:44:39 <shapr> hi JustRay 
13:49:21 * Heffalump has a go at building it with xlib too
13:51:12 * shapr plays with HUnit
13:51:29 <shapr> there's a lot of cool Haskell code out there...
15:00:55 --- quit: ChoJin ("bye !!!")
15:30:45 --- quit: Jiriki ("Reconnecting")
15:30:51 --- join: Jiriki (sjh@Riverview32.tbaytel.net) joined #haskell
16:45:10 --- quit: JustRay ("Client Exiting")
17:57:52 --- join: petersen (~petersen@firebox-ext.jp.redhat.com) joined #haskell
19:36:37 --- join: smklsmkl (~sami@glubimox.yok.utu.fi) joined #haskell
19:36:37 --- quit: smkl (Read error: 104 (Connection reset by peer))
19:52:57 --- quit: smklsmkl (carter.openprojects.net irc.openprojects.net)
19:53:15 --- join: smklsmkl (~sami@glubimox.yok.utu.fi) joined #haskell
20:15:03 --- quit: smklsmkl (Remote closed the connection)
20:15:24 --- join: smklsmkl (~sami@glubimox.yok.utu.fi) joined #haskell
20:39:42 --- quit: smklsmkl (Read error: 104 (Connection reset by peer))
20:39:44 --- join: smklsmkl (~sami@glubimox.yok.utu.fi) joined #haskell
21:09:22 --- join: jemfinch (~jemfinch@rnie-99-43.resnet.ohio-state.edu) joined #haskell
21:10:18 --- quit: jemfinch (Client Quit)
21:32:58 --- join: clausen (~andrew@c17997.eburwd3.vic.optusnet.com.au) joined #haskell
21:47:56 --- nick: smklsmkl -> smkl
22:12:52 --- join: BrutusII (BrutusII@acc1-ppp105.cof.dialup.connect.net.au) joined #haskell
22:13:23 <BrutusII> ooh.. a channell for Haskell
22:13:32 <clausen> yep!
22:13:34 <clausen> haskell rocks!
22:13:45 <clausen> where do you live?
22:13:47 * clausen melbourne
22:13:57 <clausen> (cof = Cough's Harbour?)
22:14:03 <clausen> (coff's?)
22:15:44 * clausen prods BrutusII
22:27:09 <BrutusII> oh
22:27:10 <BrutusII> yeah
22:27:12 <BrutusII> Coffs Harbour
22:27:14 <BrutusII> Sorry :)
22:27:40 * BrutusII is doing a course at Southern Cross University on Haskell
22:27:44 * BrutusII prods clausen
22:28:25 <clausen> :)
22:28:38 <clausen> SCU is in Coffs Harbour?
22:28:41 <BrutusII> Yes
22:28:53 <BrutusII> Cough's Harbour I think being the original spelling
22:29:01 <clausen> hehe
22:29:05 <BrutusII> er, Koffs harbour actually, a german name
22:29:09 <clausen> funny, since it's usually quite warm there...
22:29:15 <BrutusII> renamed when Australia at work with Germany
22:29:26 <BrutusII> It's a freakishly hot day today
22:29:58 <clausen> so, are you doing an "advanced" or "intro" course on haskell?
22:30:02 <BrutusII> Intro :)
22:30:04 <clausen> (at melbourne, haskell is the second thing they teach you
22:30:06 <clausen> after vi ;)
22:30:15 <BrutusII> Well
22:30:23 <clausen> cool :)
22:30:30 <BrutusII> Its 2nd Year, we already "done" C++, OO, yadda yadda
22:30:36 <BrutusII> er, 3rd Year
22:30:48 <clausen> ah, ok
22:31:03 <clausen> well, you learn haskell before C/Java/C++/Prolog  here :)
22:31:05 <BrutusII> Have to do evil assignments such as lexical analysers in Haskell
22:31:07 * clausen thinks it's a good first language
22:31:23 <clausen> hehe
22:31:38 <clausen> it'd be interesting to do DFA/NFA stuff in haskell
22:31:40 <BrutusII> I had Basic -> Visual Basic -> C -> C++ -> Forth -> Python imprinted in my brain, so Haskell is a little strange
22:32:54 <clausen> yeah, likewise
22:33:04 <BrutusII> And, although I really like Haskell, I don't believe it to be a practical language.
22:33:09 <clausen> (well, not that route, but I did imperative programming first)
22:33:21 <clausen> (although, I did look at scheme before haskell)
22:33:32 <clausen> yeah, it seems to be an open question still
22:33:36 <clausen> like, In Theory, it might be
22:33:48 <clausen> but a lot of Hard Thinking TM is still needed, I think
22:34:16 <BrutusII> Yes. What takes my 3 seconds in Python, I have to um and er about, then do in 5 seconds in Haskell :)
22:34:43 <clausen> but, the haskell code is half as long, hehe
22:34:46 <clausen> and works
22:34:53 <clausen> I find in python, I make typos, etc.
22:34:56 <clausen> that I discover a week later
22:35:42 <BrutusII> I have never had that myself.. Python 2.2 actually helps a lot, with Static Scoping, and __slots__
22:36:37 <clausen> maybe I should learn to use python properly...
22:37:31 <BrutusII> As they (smart people) say, its all in the detail :) And Python has that in its library's, and well designed data types
22:37:55 <BrutusII> Haskell of course being a "superior" language,
22:38:34 <clausen> I recommend you read "Purely Functional Data Structures"
22:38:36 <clausen> (interesting read)
22:38:43 <clausen> (by Chris Okasaki, IIRC)
22:38:56 <clausen> I wished they were included in standard libs!
22:38:57 <clausen> hehe
22:39:15 <BrutusII> Ok. :)
22:39:38 <clausen> but, it's still a research area, etc.
22:40:24 <BrutusII> As fun as strange languages (such as Forth, Haskell, etc..) are, basically the only thing people will use in this day and age for real projects, are Basic deriviants, C type languages, and the three P's
22:41:08 <clausen> 3 Ps?
22:41:12 <clausen> Perl, Python...
22:41:15 <clausen> Prolog (?!)
22:41:26 <BrutusII> er, Perl, Python, PHP, and pascal deriviants
22:41:30 <BrutusII> 3 meaning 4
22:41:41 <clausen> ah, ok
22:41:47 <clausen> derivatives?
22:41:53 <BrutusII> Delphi
22:41:59 <clausen> (/me never heard "deriviants" :p )
22:42:00 <clausen> yep
22:42:02 <BrutusII> and for Basic, Visual Basic
22:42:06 <clausen> SQL
22:43:38 * BrutusII has a mini-assignment to convert Numbers (numerical), to Strings, without using most standard library functions
22:43:45 <BrutusII> eg 23 to twenty three
22:43:56 <clausen> yep, I remembering doing that one, hehe
22:44:02 <clausen> why not use std lib functions?
22:44:05 * BrutusII knows how he means to do it, but is stuck with the syntax
22:44:13 <clausen> feel free to ask...
22:44:30 <BrutusII> Wait... That bit about the standard functions was only on Part 2 ...
22:44:40 <BrutusII> Oooh nice :) I don't have to rewrite the standard function
22:44:42 <BrutusII> s
23:19:07 --- quit: shapr ("worktime")
23:32:00 --- quit: Heffalump (Remote closed the connection)
23:32:43 --- join: Heffalump (ganesh@munchkin.comlab.ox.ac.uk) joined #haskell
23:34:35 --- join: Igloo (~igloo@c93.keble.ox.ac.uk) joined #haskell
23:35:20 --- quit: Igloo_ (Read error: 110 (Connection timed out))
23:45:10 --- quit: Heffalump (Read error: 104 (Connection reset by peer))
23:45:10 --- quit: Igloo (Read error: 104 (Connection reset by peer))
23:45:17 --- join: Igloo (~igloo@c93.keble.ox.ac.uk) joined #haskell
23:50:13 --- join: Heffalump (ganesh@munchkin.comlab.ox.ac.uk) joined #haskell
23:50:28 --- quit: Igloo (Remote closed the connection)
23:50:28 --- join: Igloo (~igloo@c93.keble.ox.ac.uk) joined #haskell
23:59:59 --- log: ended haskell/02.03.18