00:00:00 --- log: started haskell/02.01.23
00:11:13 --- quit: LoganH (Remote closed the connection)
01:42:34 --- join: jewel (~jleuner@57.66.12.99) joined #haskell
01:44:54 --- join: shapr (~user@p-c2fbabb9.easy.inet.fi) joined #haskell
02:11:48 --- join: Logan (~logan@up112.blacksburg.ntc-com.net) joined #haskell
02:12:05 <Logan> Haskell dojo?
02:12:11 <shapr> tada!
02:12:14 * shapr bows
02:12:15 <Logan> I wonder how I'm progressing.
02:12:43 <shapr> lemme pull up the belt color chart
02:12:50 <Logan> I'm starting to understand how to do graph theory in haskell.
02:13:04 <shapr> http://haskell.org/wiki/wiki?HaskellIrcChannel
02:13:09 <Logan> There's just one thing I can't figure out at the moment, for doing this particular problem I'm doing.
02:13:12 <shapr> cool! I wanna see code!
02:13:24 <Logan> I've got several (simple) problems I've implemented so far. :P
02:13:31 <Logan> Let me put them on a web server for you to browse, if you like.
02:13:54 <shapr> yah yah!
02:17:39 <Logan> http://www.loganh.com/haskell/
02:17:42 <Logan> Those are the ones so far.
02:17:45 <Logan> Some are really ugly. :P
02:17:54 <Logan> But most of them work.
02:18:56 <Logan> Some are solutions to a couple of problems from this problem set: http://www.acm.inf.ethz.ch/ProblemSetArchive/B_US_SouthCen/1998/index.html
02:19:01 <Logan> Others are from the 97 ACM ICPC
02:19:36 <Logan> I think I'm orange. :P
02:19:48 <Logan> If simple usage of data and type counts.
02:20:05 <Logan> Though I think I exhibit some traits of brown.
02:20:26 <Logan> So I just need to meet the requirements for green! :P
02:21:43 --- nick: Logan -> LoganH
02:23:51 <shapr> green isn't too hard
02:24:06 <shapr> I just have to think of something for blue
02:25:36 <LoganH> I don't know enough about Haskell to have a good idea of what would fit in there yet. :P
02:25:41 <shapr> me neither ;)
02:25:44 <LoganH> Maybe when I do, I'll qualify for it just by knowing.
02:25:48 <LoganH> Kind of zen-like.
02:29:45 <LoganH> I'm starting to get to the point where I really want to understand type classes.
02:29:50 <LoganH> So I can write my own general purpose code.
02:30:17 <LoganH> I should've made that cards program use memoization, but I didn't know how at the time. :P
02:30:34 <shapr> yah I know that feeling
02:34:27 <LoganH> How do I add downloaded Haskell libraries so that ghc loads them by default?
02:34:59 <shapr> ~/.ghcrc I think
02:35:07 <shapr> you can add stuff to be autoloaded there
02:35:10 <shapr> speaking of which
02:35:28 <shapr> since I'm writing the "how to download/install/use ghc and hugs" chapter of the tutorial
02:35:32 <shapr> I better find out
02:36:46 <LoganH> The instructions for htis package was: "put these files somewhere where hugs/ghc can find them and Load FGL". :P
02:37:03 <shapr> sounds reasonable
02:37:35 <LoganH> How do I tell ghc which directories to look in for .hs files I request to load?
02:38:52 <shapr> er, searching...
02:40:41 <shapr> this is part of the answer: http://haskell.org/ghc/docs/latest/set/ghci-dot-files.html
02:41:37 <LoganH> Hmm, -i
02:41:48 <LoganH> What in other compilers would be -I. :P
02:41:55 <shapr> One or more modules or filenames can also be specified on the command line; this instructs GHCi to load the specified modules or filenames (and all the modules they depend on)
02:42:31 <shapr> since I'm used to using export PYTHONSTARTUP=/home/shae/startup.py
02:42:52 <shapr> I'll probably make a /home/shae/src/haskell/ghcistart.hs
02:43:08 <shapr> and load that from my ~/.ghci
02:45:18 <shapr> is that what you were asking for?
02:46:17 <LoganH> Hmm, -i isn't working for me.
03:05:57 <LoganH> Have you used FGL?
03:06:04 <LoganH> Unfortunately it doesn't seem to compile in ghc. ):
03:07:57 <shapr> nah, I haven't tried it, but I will now
03:08:30 <LoganH> RootPath.hs:17:
03:08:31 <LoganH>     Illegal instance declaration for `Eq (LPath a)'
03:08:31 <LoganH>         (The instance type must be of form (T a b c)
03:08:31 <LoganH>          where T is not a synonym, and a,b,c are distinct type variables)
03:08:31 <LoganH>     In the instance declaration for `Eq (LPath a)'
03:08:33 <LoganH> RootPath.hs:20:
03:08:35 <LoganH>     Illegal instance declaration for `Ord (LPath a)'
03:08:38 <LoganH>         (The instance type must be of form (T a b c)
03:08:40 <LoganH>          where T is not a synonym, and a,b,c are distinct type variables)
03:08:43 <LoganH>     In the instance declaration for `Ord (LPath a)'
03:09:09 <shapr> try it with -fglasgow-exts
03:10:21 <LoganH> Overlapping instance declarations:
03:10:21 <LoganH>   RootPath.hs:17: Eq (LPath a)
03:10:21 <LoganH>   /usr/lib/ghc-5.02/imports/std/PrelBase.hi:165: Eq [a]
03:10:21 <LoganH> Overlapping instance declarations:
03:10:21 <LoganH>   RootPath.hs:20: Ord (LPath a)
03:10:23 <LoganH>   /usr/lib/ghc-5.02/imports/std/PrelBase.hi:166: Ord [a]
03:10:33 <LoganH> I need to learn what these instances are.
03:11:04 <shapr> instances have to do with type classes
03:11:25 * LoganH nods.
03:11:34 <shapr> have you used Java?
03:11:36 <LoganH> Yes.
03:11:44 <shapr> you understand interfaces in Java?
03:11:49 <LoganH> Yes.
03:12:05 <shapr> that's pretty close to type classes in Haskell
03:12:13 <shapr> take the Show class for example
03:12:15 <Heffalump> LoganH: what's the definition of LPath?
03:12:51 <Heffalump> in general don't use -fglasgow-exts or -98 or whatever unless you know why you need it (e.g. using someone else's code that says you need it :-)
03:12:59 <shapr> oh
03:13:06 <shapr> it often fixes my problems :)
03:13:12 <Heffalump> with your own code?
03:13:21 <shapr> no, with other code
03:13:32 <Heffalump> right, yes, other code is often written to use specific extensions
03:13:35 <Heffalump> so you have little choice
03:13:37 <LoganH> Members of the Show class are types that have a show function defined for them?
03:13:43 <shapr> right
03:13:48 <Heffalump> LoganH: and have an instance definition saying they are
03:13:55 <LoganH> type LPath a   = [LNode a]
03:14:02 <Heffalump> shapr: for your own code, you really ought to understand *why* you need the instance first
03:14:08 <LoganH> type  Node     = Int
03:14:09 <LoganH> type LNode a   = (Node,a)
03:14:09 <shapr> Heffalump: I completely agree!
03:14:17 <Heffalump> loganH: and you're trying to write "instance Eq (LPath a)" ?
03:14:37 <LoganH> Well, I'm not, it's in this functional graph library I got from http://cs.oregonstate.edu/~erwig/fgl/haskell/ :P
03:14:44 <Heffalump> oh, right
03:14:46 <Heffalump> ummm
03:15:01 * Heffalump --> look at it
03:15:13 <shapr> data Temp = Cold | Hot
03:15:21 <shapr> -- ok let's add Temp to the Eq class
03:15:21 <shapr> instance Eq Temp where
03:15:21 <shapr>     Cold == Cold = True
03:15:21 <shapr>     Hot == Hot = True
03:15:21 <shapr>     _ == _ = False
03:15:55 <shapr> so Eq is a typeclass
03:16:01 * LoganH nods.
03:16:19 <shapr> oh, here's one I wrote to figure it out for myself:
03:16:22 <LoganH> Specifying types whose values have equivalence (implemented by the == function) defined for them.
03:16:27 <shapr> class CharExts a where
03:16:27 <shapr>     isVowel     :: a -> Bool
03:16:27 <shapr>     isConsonant :: a -> Bool
03:16:34 <shapr> instance CharExts Char where
03:16:34 <shapr>     isVowel a     = elem a "aeiouAEIOU"
03:16:34 <shapr>     isConsonant a = elem a (filter (not . isVowel) ['A'..'Z'] ++ ['a'..'z'])
03:17:05 * LoganH nods.
03:17:14 <LoganH> I'll have to start using polymorphism soon.
03:17:26 * Heffalump reads the code and goes *ick*
03:17:50 <Heffalump> it *might* work but I don't understand why they're using a type synonym for LPath
03:18:02 <shapr> LoganH: how so polymorphism?
03:18:23 <LoganH> An LPath (labelled path) is a list of labelled nodes (LNode).
03:18:35 <LoganH> An LNode differs from a Node in that it's an ordered pair of a label and a Node.
03:18:37 <Heffalump> loganH: yes, it's the use of a type synonym that's ugly
03:18:49 <LoganH> I don't know enough to know why it's ugly. :P
03:18:53 <Heffalump> because they're trying to make equality be something different to what it would be on lists, yet a LPath is just a (specific) list
03:19:08 <LoganH> Maybe they want to leave room for change?
03:19:12 <LoganH> In case someday LPath isn't just a list?
03:19:19 <Heffalump> but they could have used newtype
03:19:26 <Heffalump> which would do the job perfectly, with a little extra effort
03:19:28 <LoganH> I don't know about newtype. :P
03:19:42 <LoganH> I think this code was o riginally written in ML, if that explains anything about their style.
03:19:51 <shapr> I only know what Heffalump taught me about newtype :)
03:19:54 <Heffalump> but the authors of this library should have
03:19:59 <Heffalump> hmm, right
03:21:25 <LoganH> So what is the reason for the compile error in RootPath.hs?
03:21:57 <LoganH> And are there any other haskell libraries that provide functional graph implementations?
03:24:41 <shapr> LoganH: http://www.dcs.gla.ac.uk/~gnik/publications.html ?
03:25:49 <shapr> http://www.pms.informatik.uni-muenchen.de/mitarbeiter/panne/haskell_libs/daVinci.html
03:26:21 <shapr> ooh ahh, Haskell talks to daVinci, an X-windows directed graph visualization tool
03:26:56 <LoganH> Hmm, never heard of daVinci.
03:26:59 <LoganH> I've only used graphViz.
03:27:23 <LoganH> I'm unable to reach that first URL you posted.
03:28:19 <shapr> the first url contains a thesis dealing with graph algorithms in Haskell
03:28:33 <shapr> why it's a good idea, what kind of nifty things it lets you do, etc
03:29:56 <LoganH> Is it the same as http://cs.oregonstate.edu/~erwig/papers/abstracts.html#JFP01 ?
03:31:06 <shapr> nope
03:31:33 <LoganH> Is there code associated with it? :P
03:31:54 <shapr> it's ~275k of gzipped postscript
03:32:51 <shapr> author is DJ King
03:33:17 <shapr> google says he's written at least two papers on graph algorithms in Haskell
03:33:18 <LoganH> http://haskell.org/wiki/wiki?PreludeListFunctions <- should've found this earlier. *grin*
03:33:29 <LoganH> Maybe I can find a mirror on a reachable site.
03:34:14 <shapr> or I can email it to you
03:35:30 <LoganH> I have Structuring Depth-First Search Algorithms in Haskell, and Lazy Depth-First Search and Linear Graph Algorithms in Haskell.
03:36:42 <LoganH> I might try rolling my own graph implementation for now.
03:36:45 <shapr> ok
03:36:53 <LoganH> It'll be inefficient, but it'll aquaint me with types.
03:36:59 <shapr> and that's the point
03:37:22 <LoganH> Inefficiency? :P
03:37:32 <shapr> no, learning :-P
03:51:51 <Heffalump> DJ King's stuff is good for certain things but possibly not as a generalised graph toolkit
03:56:49 <LoganH> How about Erwig's?
03:56:57 <Heffalump> not looked at it, sorry
03:58:50 <LoganH> http://cs.oregonstate.edu/~erwig/papers/abstracts.html#JFP01
03:59:00 <LoganH> The implementation of that FGL library is based on that paper.
04:00:54 <Heffalump> oh, right
04:02:04 <Heffalump> hmm, looks useful at a very first glance
04:02:20 <Heffalump> but be a bit careful of using recent research for real practical problems :-)
04:15:46 --- join: SolidCore (~fractal@ppp-64-206-116.friaco.access.uk.tiscali.com) joined #haskell
04:15:58 * LoganH nods.
04:16:06 <LoganH> As opposed to using code I wrote myself? :P
04:16:06 <SolidCore> hi
04:16:24 <SolidCore> anyone know Delphi?
04:16:39 <jewel> you mean pascal?
04:16:53 <SolidCore> me? nahh delphi
04:17:04 <SolidCore> Bordland Delphi 6 
04:17:04 <jewel> hehe
04:17:11 <SolidCore> :)-
04:17:28 <SolidCore> well? does anyone know delphi
04:17:36 <jewel> this channel is about haskell
04:17:53 <SolidCore> whats haskell
04:18:01 <SolidCore> paskell
04:18:03 <jewel> look at www.haskell.org
04:18:15 <SolidCore> nahhh im downloading... take me along time
04:18:23 * jewel lols
04:18:24 <SolidCore> go on just give me a brief
04:18:33 <jewel> you can't read?
04:18:41 <SolidCore> ahh w8
04:18:51 <SolidCore> so u guys are doing functional progrsamming
04:18:56 <SolidCore> whats that like then?
04:19:32 <jewel> quite different
04:21:06 <xbill> SolidCore: with bananas, lenses, envelopes, and barbed wire
04:29:14 <shapr> paskell
04:29:18 <shapr> BWAHAHAA
04:29:21 * shapr falls over laughing
04:30:41 <shapr> I think I need to create a quotefile for #haskell
04:44:05 --- join: oofun (alfredding@61.171.126.249) joined #haskell
04:44:07 --- part: oofun left #haskell
04:45:13 <LoganH> Heh, I mentioned haskell to my roommate, and he thought I was talking about pascal.
04:46:12 --- quit: SolidCore (Read error: 110 (Connection timed out))
05:10:13 <Heffalump> xbill: lol
05:10:34 * Heffalump is from the uni that was at one point part of that movemement :-)
05:11:40 <shapr> er, which movemement?
05:11:47 <shapr> Paskell?
05:12:27 <Heffalump> the bananas, lenses etc comment
05:12:50 <Heffalump> loganh: I get that all the time
05:13:30 <Heffalump> shapr: there's a paper by Meijer, Fokinga and Paterson (and possibly someone else) with a title that goes something like xbill's quote above
05:14:04 <Heffalump> it's a reference to category theory, which has some relation to Haskell
05:14:22 <Heffalump> category theory has lots of operators that look a bit "weird"
05:17:21 <shapr> aha
05:17:24 <shapr> fokkinga 
05:20:53 --- quit: dblack ("[x]chat")
05:20:54 <shapr> http://research.microsoft.com/~emeijer/
05:20:58 <shapr> under "software design"
05:22:33 <Heffalump> that's the bunny
06:09:12 <jewel> ma ractu
06:10:04 <jewel> .ua le badna
06:30:04 --- join: dblack (~dblack@shunat236-80.shu.edu) joined #haskell
07:16:37 * jewel browses Erik's thesis
07:49:50 <shapr> coi
08:25:00 --- quit: shapr ("shooting people")
09:28:30 --- quit: smkl (Remote closed the connection)
09:30:56 <jewel> "we are releasing now new beta compilers for Mondrian and Haskell for .NET."
09:31:38 <Heffalump> where'd you see that?
09:31:56 <Heffalump> last I heard, the .NET code generation in GHC was severly broken
09:32:13 <jewel> http://www.mondrian-script.org/
09:32:56 <xbill> Haskell proper seems to do well enough for scripting.
09:34:44 --- join: smkl (~sami@glubimox.yok.utu.fi) joined #haskell
09:34:45 --- quit: smkl (Remote closed the connection)
09:36:35 <Heffalump> hmm.
09:36:40 * Heffalump should poke that
09:37:38 --- join: ajoyagua (~ismael@62.83.28.29) joined #haskell
09:52:36 --- join: smkl (~sami@glubimox.yok.utu.fi) joined #haskell
09:56:36 --- quit: ajoyagua ("Aplicación Saliendo")
10:10:59 --- join: jemfinch_ (~jemfinch@rpat-100-139.resnet.ohio-state.edu) joined #haskell
10:11:08 --- quit: jemfinch` (Read error: 104 (Connection reset by peer))
10:38:01 --- join: shapr (~user@p-c2fbabb9.easy.inet.fi) joined #haskell
10:48:45 --- join: jsw (scott@12-234-202-177.client.attbi.com) joined #haskell
10:50:57 --- quit: shapr (Remote closed the connection)
11:12:17 --- join: djul (~jleuner@57.66.12.99) joined #haskell
11:28:00 --- quit: jewel (Read error: 110 (Connection timed out))
12:15:17 --- quit: dblack ("[x]chat")
12:34:10 * LoganH yawns.
13:13:10 --- join: dblack (~dblack@ool-18be3b59.dyn.optonline.net) joined #haskell
13:26:19 --- quit: smkl (Read error: 104 (Connection reset by peer))
13:26:48 --- join: smkl (~sami@glubimox.yok.utu.fi) joined #haskell
13:57:36 --- join: lodewijk (~lodewijk@voge.xs4all.nl) joined #haskell
14:25:02 --- quit: lodewijk ("BitchX: strong enough for a man, pH-balanced for a woman")
15:51:15 --- join: shapr (~user@p-c2fbabb9.easy.inet.fi) joined #haskell
16:13:44 --- quit: shapr (Remote closed the connection)
16:37:19 --- join: ajoyagua (~ismael@195-MADR-X27.libre.retevision.es) joined #haskell
16:43:33 --- quit: LoganH (Read error: 104 (Connection reset by peer))
16:43:55 --- join: Logan (~logan@up112.blacksburg.ntc-com.net) joined #haskell
16:44:15 --- quit: ajoyagua ("Aplicación Saliendo")
17:58:56 --- quit: dmiles (Read error: 104 (Connection reset by peer))
18:57:34 <Logan> Heh, doing an on line programming competition in C++ tonight.
18:57:39 <Logan> And I'm really wishing I could've used haskell!
19:57:14 --- quit: pHa ("O_O")
20:01:11 --- join: pHa (sjh@Rockcliffe10.tbaytel.net) joined #haskell
20:03:22 --- join: dmiles (~alife@sense-sea-MegaSub-2-56.oz.net) joined #haskell
21:11:39 <Logan> I'm really getting into this type polymorphism stuff.
21:47:59 --- quit: pHa ("Reconnecting")
21:48:03 --- join: pHa (sjh@207.164.213.77) joined #haskell
22:00:03 --- join: dennisb (~dennis@as2-4-3.an.g.bonet.se) joined #haskell
22:10:05 <jemfinch_> Logan: how so?
22:21:21 <Logan> Just starting to use it.
22:21:33 <Logan> It seems more intuitive than in other languages I've used.
22:28:25 <jemfinch_> cool :)
22:28:29 <jemfinch_> what are the other ones you've used?
22:33:26 --- nick: jemfinch_ -> jemfinch
22:33:56 <Logan> Well, the closest to this sort of power I guess would be C++ templates (which are ugly, complicated, and not as intuitive).
22:34:20 <Logan> Is there a built-in function that is just the identity?  (e.g., equivalent to \x -> x ?)
22:35:03 <jemfinch> I don't know :-/
22:35:11 <jemfinch> I actually don't program in Haskell.
22:35:44 <jemfinch> which feature of Haskell are you talking about in particular?
22:36:54 <Logan> id :P
22:37:00 <Logan> The type system.
22:38:29 <jemfinch> are you talking about the ability to declare classes of types that can be used with a certain function that's unique to Haskell?  Or just the plain old type inference/parametric polymorphism that's in ML and such too?
22:39:57 <Logan> Well, I have no experience of ML. :P
22:42:43 <jemfinch> what languages do you have experience in?
22:42:55 <jemfinch> (does what you're talking about involve Haskell's "class" keyword?)
22:53:02 <jemfinch> I'd have hard time saying anything in the strictly typed systems of Haskell/ML is as powerful as C++ templates.
23:15:00 <Logan> This is my first major foray into functional programming.
23:16:35 <jemfinch> ah, ok.
23:59:59 --- log: ended haskell/02.01.23