00:00:00 --- log: started haskell/02.01.06
00:02:53 --- join: teek (teemu@k72.viikki.hoasnet.fi) joined #haskell
02:24:04 --- quit: teek ("[x]chat")
03:04:10 --- join: teek (teemu@k72.viikki.hoasnet.fi) joined #haskell
03:27:46 --- join: Ice-Cold (~dornj@ekgr-dsl-stat-net-t146.citlink.net) joined #haskell
03:28:10 --- part: Ice-Cold left #haskell
03:51:15 --- join: nodie (~nodie@213-99-209-169.uc.nombres.ttd.es) joined #haskell
03:51:28 --- part: nodie left #haskell
04:02:59 --- quit: teek ("[x]chat")
04:20:20 --- join: jsw (scott@12-234-202-177.client.attbi.com) joined #haskell
04:23:22 <jsw> I recently downloaded and installed ghc.  Was wondering why finite maps are implemented using balanced binary trees rather than hash tables.  Seems like the latter would be quicker, but am new to language.
04:38:00 <smkl> finite maps are a functional datastruture
04:39:10 <smkl> hash tables are only faster for inplace operations
04:39:32 <smkl> (at least the usual ones)
04:47:25 <jsw> The finite map functions seemed to return the map data structure, and so don't need the IO monad.  But one still has to keep passing that structure back into map functions.
04:47:51 <jsw> Haskell code seems really readable, but it takes a bit of getting used to.
04:50:07 <jsw> I'm also just getting used to IRC, I'll have to come back here during PST daylight hours, what folks are saying about this language.  I've done Lisp for a while, but really what I've seen in Haskell.
04:55:02 <smkl> ok
05:00:36 <jsw> hmm, maybe I'll be more coherent during daylight hours as well...
05:00:46 --- part: jsw left #haskell
10:12:07 --- quit: xbill ("Leaving")
12:05:52 --- quit: jlb (Success)
12:08:21 --- join: jlb (~ktk@jeremeydsl-3.mylinuxisp.com) joined #haskell
13:36:40 --- join: shapr (~user@p-c2fbaba8.easy.inet.fi) joined #haskell
14:15:04 --- join: matju (~matju@HSE-Montreal-ppp3465099.sympatico.ca) joined #haskell
14:15:50 <shapr> hi
14:16:22 <matju> hi
14:16:46 <matju> http://www.pragmaticprogrammer.com/loty/
14:16:49 <shapr> what's up?
14:17:00 <shapr> yah, same here :)
14:17:20 * shapr goes off to join the Yahoo group
14:17:30 <shapr> oh cool, this year's language is Haskell!
14:17:32 <shapr> awesome!
14:17:47 <shapr> I must post this to the haskell list
14:17:53 <matju> i told the #loty people that there's also #haskell here
14:18:00 <matju> the #loty people are also #ruby-lang people.
14:18:28 <shapr> awesome :)
14:20:31 <matju> http://www.ruby-talk.com/blade/30372
14:21:33 --- join: chad (trilluser@65.15.137.250) joined #haskell
14:38:32 * shapr tries to join the yahoogroup
14:38:32 <shapr> hmm
15:03:57 --- join: jsw (scott@12-234-202-177.client.attbi.com) joined #haskell
15:08:39 --- join: jscott (scott@12-234-202-177.client.attbi.com) joined #haskell
15:09:36 --- part: jscott left #haskell
15:21:15 --- join: Slashdog (~jadrian@dial-b3-96-166.telepac.pt) joined #haskell
15:21:25 --- nick: Slashdog -> jadrian
15:21:27 <jadrian> hi all
15:21:42 <jadrian> any ghc users in here?
15:22:57 <jadrian> <- would appreciate a couple of hints... (not actually knowing anyone else who codes in haskell sucks :(  )
15:23:16 <shapr> hi jadrian
15:23:19 <shapr> what's up?
15:23:21 <jadrian> hi shapr
15:23:37 <shapr> do you have any questions?
15:23:40 <jadrian> I'm trying to makes some stuff in haskell (GAs, NN etc)
15:23:42 <jadrian> yeap
15:23:56 <shapr> I'm still newbie quality, but I'll try to help you out
15:24:05 <jadrian> I was begining to coda a simple GA
15:24:05 <jadrian> (genetic algorithm)
15:24:09 <shapr> yah
15:24:11 <shapr> ?
15:24:32 <jadrian> ah... newbie... it'll probablçy be way to complicated ... anyway
15:24:54 <jadrian> I 1st thought abouth generating a couple of infinite lists of random values and pass them around
15:25:28 <shapr> what are you trying do?
15:25:42 <shapr> as in, what problem do you want your GA to solve?
15:25:43 <jadrian> randomizing the value whjen needed would suck because they would become IO
15:25:59 <jadrian> well right now I want it to be as general as possible
15:26:17 <jadrian> I was thinking about just get the maximum of some function for instance, to try it out
15:26:25 <jadrian> I want to start with something simple
15:26:25 <shapr> yah
15:26:46 <jadrian> anyway, my question as to do with the ST module in the lang category of GHC
15:26:47 <shapr> have you written any GAs in other languages?
15:26:49 <jadrian> ever used it?
15:26:57 <shapr> not that I'm aware of
15:27:00 <jadrian> :(
15:27:29 <shapr> what does it do?
15:27:31 <jadrian> well passing infinite lists of random values as an argument to all the functions doesn't seem to be very elegant
15:27:43 <shapr> that's true
15:28:10 <jadrian> and I'd probably like to control the number of mutations and the best value in each generation
15:28:11 <shapr> I know you can pass one of the expandable state monad guys around in your function
15:28:21 <shapr> why not make a Random Monad that you pass around?
15:28:46 <jadrian> and passing around those values also sucks (and I'll need to keep changing the signatures as I want different things)
15:28:47 <jadrian> yeap
15:28:51 <jadrian> that's my idea
15:28:57 <shapr> sounds good to me
15:29:11 <jadrian> I've not worked taht much with monads though :)
15:29:15 <jadrian> so yeasterday
15:29:25 <shapr> have you tried to make it work?
15:29:29 <shapr> got any code?
15:29:35 <jadrian> I downloaded the 'Monads for rthe working programmer' paper
15:29:45 <jadrian> I'm about to
15:29:53 <jadrian> I've been playing around with monads
15:30:02 <jadrian> but I don't want to reeinvent the weel 
15:30:17 <jadrian> the ST module seems to be a state module
15:30:25 <jadrian> a general one
15:30:35 <shapr> yah, that's why it sounds familar
15:30:38 <shapr> er, familiar :)
15:31:03 <jadrian> I thought I'd use that but I wanted to check if it was a good idea
15:31:55 <shapr> looks like there's a RandList module in the data module
15:32:07 <shapr> there's also a Random module
15:32:10 <jadrian> let me check
15:32:27 <jadrian> Random is a Standard one
15:33:30 <jadrian> randomRs :: RandomGen g => (a, a) -> g -> [a]
15:33:46 <jadrian> this is what I was passing around
15:33:47 <jadrian> random lists
15:34:02 <shapr> why are you passing them around?
15:34:51 <jadrian> can't find any RandList module... 
15:35:14 <jadrian> well if I generated the random when I need them
15:35:23 <jadrian> those functions would be either IO
15:36:01 <jadrian> or Id have to pass a StdGen around
15:36:18 <shapr> ghc -package data
15:36:22 <shapr> will let you get RandomList
15:36:26 <shapr> er, RandList
15:36:43 <shapr> if you're using Linux, go to /usr/lib/ghc/imports
15:36:52 <shapr> and run fgrep -ri andom *|less
15:36:56 <jadrian> 3. The data category: datatypes
15:36:56 <jadrian> 3.1. Edison
15:36:56 <jadrian> 3.2. The FiniteMap type
15:36:56 <jadrian> 3.3. Set
15:37:01 <jadrian> just got that in the library section...
15:37:59 <jadrian> mmmm maybe Edison stuff?
15:38:30 <jadrian> anyway I'll need to use a State monad to make this right...
15:38:50 * shapr dunno
15:39:14 <jadrian> was just wondering about all this operations... 
15:39:40 <shapr> I've heard people here talk about it, but I've not done it myself
15:40:18 <jadrian> there are lots of stuff in the ST module that I don't know what's for
15:40:18 <jadrian> and they'd probably be handy
15:40:50 <shapr> yah, I agree
15:41:22 <jadrian> If I'm going to use this module I'd like to use it right.. but there is not really documentation
15:41:37 <shapr> well, gotta use it wrong to know what's right
15:41:38 <jadrian> just the signatures :(
15:42:16 <jadrian> well the problem is that I may end up not using some things that could be useful and make my code more elegant 
15:42:29 <shapr> you can always fix it later
15:42:33 <shapr> life isn't perfect :)
15:43:00 <jadrian> yeap... you're right there :)
15:43:37 <jadrian> like:
15:43:40 <jadrian> data STRef s a     -- mutable variables in state thread s
15:43:40 <jadrian>                    -- containing values of type a.
15:43:40 <jadrian> newSTRef           :: a -> ST s (STRef s a)
15:43:40 <jadrian> readSTRef          :: STRef s a -> ST s a
15:43:40 <jadrian> writeSTRef         :: STRef s a -> a -> ST s ()
15:43:41 <jadrian> modifySTRef        :: STRef s a -> (a -> a) -> ST s ()
15:44:17 <jadrian> I think I have a pretty good idea of what they do...
15:44:31 <jadrian> even though a couple of examples would be pretty nice...
15:45:34 <jadrian> oh well... I'll just have to try them out... :)
15:45:48 <shapr> yah, good idea
15:46:35 <jadrian> but I wish there was better and more documentation...
15:47:20 --- quit: jlb (carter.openprojects.net irc.openprojects.net)
15:47:20 --- quit: chad (carter.openprojects.net irc.openprojects.net)
15:47:20 --- quit: pHa (carter.openprojects.net irc.openprojects.net)
15:47:34 <jadrian> lack of documentation + knowing no one who uses haskell  doesn't help much :)
15:47:55 <shapr> people here do use haskell, and are knowledgable
15:47:59 <shapr> they're just not awake right now
15:48:21 <jadrian> I meant in real life...
15:48:46 <jadrian> I don't know anyone who knows the language
15:48:52 <shapr> oh, this year is the first year I've known other people who can program at all
15:49:12 <jadrian> it is not taught at my University :(
15:49:35 <shapr> I don't know anyone in real life who knows Python, Javascript, VBScript, JScript, SQL, C, or C++
15:49:44 <shapr> I do know one person who knows Java though.
15:49:46 <jadrian> lol :)
15:49:46 <shapr> that's it :)
15:49:49 <shapr> I never went to uni
15:49:55 <shapr> well, not for computers at least
15:50:08 <shapr> my major was women 8)
15:50:15 <jadrian> mmm and learning haskell... nice :)
15:50:21 <jadrian> lol nice major ;)
15:50:33 <shapr> yah, it worked for me
15:51:23 <shapr> I'd like to meet another haskeller in person
15:51:23 <jadrian> so tell me, what do you think of the language... I mean, how hard do you think it was moving from imperative and POO to Functional (and pure and lazy)
15:51:38 <shapr> pretty damn hard
15:51:40 <jadrian> lol
15:51:42 <jadrian> :)
15:51:46 <shapr> luckily, I love recursion
15:51:59 <shapr> and Python (my former favorite language) has lots of FP tools
15:52:06 <shapr> like map, apply, reduce, etc
15:52:16 <jadrian> yes of course
15:52:21 <shapr> it's about 75% of the stuff I've later found in Scheme, elisp, and now in Haskell
15:52:38 <shapr> it's still really confusing, but I'm getting the hang of it
15:52:51 <jadrian> still Monads, as far as I know are only present in haskell
15:53:08 <shapr> nah, they're in Scheme also
15:53:16 <jadrian> oh yeah? didn't know that
15:53:37 <jadrian> any favourite lang so far?
15:53:39 <shapr> someone who knows more than I do said that
15:53:46 <shapr> yah, Python is my 'first love' I guess
15:53:58 <shapr> I thought Java was, but when I found Python, I discovered that Java sucks
15:54:03 <jadrian> lol
15:54:22 <shapr> but then Guido (the guy who runs Python) decided against having first class continuations in Python
15:54:29 <jadrian> haven't tryed python yet... it's in my ToDo list
15:54:32 <shapr> so I got pissed off and had to find a new language
15:54:37 <shapr> Python is truly beautiful
15:54:42 <shapr> it's amazingly elegant
15:54:57 <shapr> it's also that pretty to look at too :)
15:55:05 <jadrian> :)
15:55:15 <shapr> python is the closest I've ever been to really writing executable poetry
15:55:23 <shapr> but I've noticed that Haskell is going to get me closer
15:55:28 <jadrian> lol... definitly got to check that out :)
15:56:33 <jadrian> yeap, I really like haskell... just used to have someone around and share ideas when I'm using other languages
15:56:44 <shapr> hey, #haskell is a good place to do that
15:57:10 <jadrian> yeap... usually a lil quiet though :)
15:57:14 <shapr> and we'll be getting more people soon
15:57:20 <shapr> well, hang around and start conversations
15:57:22 <shapr> it works
15:57:29 --- join: pHa (sjh@aircomm-1blk-220-10.air.on.ca) joined #haskell
15:57:32 <jadrian> yeap seems to work :)
15:57:35 <shapr> sadly, I need to go to bed now :(
15:57:39 <jadrian> me too
15:57:40 <shapr> I gotta work tomorrow
15:57:44 <shapr> g'nite jadrian
15:57:44 <jadrian> midnight here
15:57:48 <jadrian> see ya shapr
15:57:48 <shapr> 2am here
15:57:51 <jadrian> wow
15:57:53 * shapr goes to sleep
15:57:59 --- quit: jadrian ("Client Exiting")
16:00:03 --- join: jlb (~ktk@jeremeydsl-3.mylinuxisp.com) joined #haskell
16:41:01 --- quit: kepler (Remote closed the connection)
17:00:30 --- join: jadrian (~jadrian@dial-b1-198-138.telepac.pt) joined #haskell
17:00:38 * jadrian walks in... again
17:00:43 <matju> shapr: Ruby has first-class continuations.
17:01:00 <jadrian> hey matju, shapr
17:01:28 <matju> jadrian: shapr has gone to sleep.
17:01:43 <jadrian> k, hi matju then :)
17:02:06 <jadrian> matju: tell me something, have you used the ST module in ghc...
17:02:19 <jadrian> I'm having some trouble figuring out how to use it...
17:02:26 <jadrian> :(
17:07:16 <matju> jadrian: i don't know Haskell =)
17:08:14 <jadrian> :(
17:27:21 <jadrian> so no gh cusers actually here :(
17:27:35 <jadrian> ghc even
17:28:36 <jsw> I've used ghc, but am also fairly new, so am sort of lurking at the moment
17:28:57 <jadrian> Hi jsw
17:29:19 <jadrian> know anything about the ST module?
17:29:28 <jadrian> State Transformer
17:29:57 <jsw> hi developing web app.  Was really impressed using greencard for FastCGI interface.
17:30:07 <jsw> Sorry, haven't figured out ST yet.
17:30:10 <jadrian> :(
17:30:46 <jadrian> I just wanted to se a simple example and I would probably figure out how to use it 
17:49:38 <jsw> I suppose it's little help, but the ST doc at http://haskell.cs.yale.edu/ghc/docs/latest/set/sec-st.html mentions a paper.  I couldn't find the paper though.
17:50:26 <jadrian> yeap I got it 
17:50:57 <jadrian> been looking at it... it's kind of old, I think it has changed, but got to check it out better
17:51:30 <jadrian> and there is not one example on that paper
17:51:53 <jsw> oh, man that's too bad.
17:54:50 --- join: lodewijk (~lodewijk@voge.xs4all.nl) joined #haskell
17:56:04 <jadrian> hi lodewijk
17:56:06 <jsw> The way I'm doing my web application, I don't really need concurrency, let alone the advantages of ST over the normal concurrency primitives.
17:56:28 <jadrian> I'm not even thinking about using concurrency...
17:56:49 <lodewijk> hi. I'm trying to learn haskell, and one thing I don't get is input/output
17:57:08 <jadrian> but I'll need keep track of some information
17:57:23 <jadrian> lodewijk: yeap.. the evil Monads :)
17:57:39 <jadrian> jsw: I'm implementing some simple GA
17:57:41 <lodewijk> take readFile for example, it returns an IO String. but then what? I can't pass it to functions that take a String, it'll flag a type error. /me don't get it
17:58:07 <jsw> oops, i thought that ST gave you some kind of concurrency, because of it's mention of threading.
17:58:09 <jadrian> lodewijk: yeap, you can
17:58:46 <jadrian> lodewijk: but the function where you 'catch' the string you read will be of type IO(a)
17:58:55 <jadrian> where a is some other type
17:59:20 --- join: juhp (~petersen@firebox-ext.jp.redhat.com) joined #haskell
17:59:38 <lodewijk> but take this for example:
17:59:42 <jsw> yeah monads are trick that way, you have to use some sort of (IO fun) >>= /val -> (do stuff with fun result) to get at it
17:59:47 <lodewijk> Prelude> lines (readFile "actuals.txt")
17:59:47 <lodewijk> ERROR - Type error in application
17:59:47 <lodewijk> *** Expression     : lines (readFile "actuals.txt")
17:59:47 <lodewijk> *** Term           : readFile "actuals.txt"
17:59:47 <lodewijk> *** Type           : IO String
17:59:48 <lodewijk> *** Does not match : [Char]
17:59:58 <jadrian> yeap
18:00:02 <jadrian> hi juhp
18:00:35 <juhp> hi jadrian
18:00:36 <jadrian> if you want to use that String in some f function you will have to make
18:00:46 <lodewijk> jsw: ah. I came across that, but it wasn't clear to me that that's what it's used for
18:00:53 <jsw> can you try (readFile "actuals.txt") >>= /text -> (show text)
18:00:56 <jadrian> foo = do
18:01:09 <jadrian>     str <- readFile someFile
18:01:38 <jadrian>    f str     
18:01:38 <jadrian> for instance
18:01:41 <lodewijk> jsw: /text gives a syntax error, \text gives another type error
18:01:44 <jadrian> juhp: ghc user?
18:02:02 <lodewijk> I'm on hugs here btw, let me check ghc
18:02:09 <juhp> jadrian: yeah, i am mainly using ghc
18:02:23 <jadrian> know anything about the ST Monad?
18:02:32 <jadrian> can't find any documentation
18:02:33 <jadrian> :(((
18:02:41 <jadrian> State Transformer
18:02:53 <juhp> hmmm, not too much.
18:03:10 <jsw> yep, should have been a `\`, thats what you get when a newbie offers advise :-)
18:03:16 <jadrian> damn... I already read the "Monads for the worker programmer" tutorial
18:03:33 <jadrian> but the ST on ghc is diferent
18:03:42 <jadrian> still didn't figure out how to use it
18:03:50 <juhp> ah, really
18:03:55 <jadrian> yeap
18:04:04 <juhp> how is it different?
18:04:25 <jadrian> well in the tuturial you have
18:04:51 <jadrian> applyST :: StateTrans s a -> s -> (s, a)
18:04:52 <jadrian> applyST (ST p) s = p s
18:05:07 <jadrian> pretty simple
18:05:11 <juhp> ok
18:05:23 <jadrian> you apply it to an initial state
18:05:40 <jadrian> and I understood how everything works
18:05:56 <jadrian> you also have
18:06:07 <jadrian> for instance this example
18:06:16 <jadrian> type ImpState = (Int, Int)
18:06:21 <jadrian> getX, getY :: StateTrans ImpState Int
18:06:21 <jadrian> getX = ST(\(x,y)-> ((x,y), x))
18:06:21 <jadrian> getY = ST(\(x,y)-> ((x,y), y))
18:06:47 <juhp> aha
18:06:54 <jadrian> it's pretty simple, this function allow you to access the state
18:07:09 <lodewijk> ah, okay, I get the "do" thing now. I'll go a prod that a bit then. 
18:07:15 <jadrian> well you can't really use ST as it is an abstrct data type
18:07:20 <juhp> never used the ST module in hslibs personally
18:07:23 <jadrian> in ghc that is
18:08:08 <jadrian> well it is different from this in ghc
18:08:25 <jadrian> like I said you can't use ST to access state, so I was expecting to have
18:08:36 --- topic: set to 'Functional Programming, that's the opposite of Dysfunctional Programming (like VB) | we be loggin' http://tunes.org/~nef/logs/haskell/ | welcome to the Haskell Dojo | julien and shapr are up to white belt!the apply function defined' by jadrian
18:08:43 <jadrian> opsss
18:08:54 --- topic: set to 'Functional Programming, that's the opposite of Dysfunctional Programming (like VB) | we be loggin' http://tunes.org/~nef/logs/haskell/ | welcome to the Haskell Dojo | julien and shapr are up to white belt!' by jadrian
18:08:54 <jsw> lodewijk: try  (readFile "actuals.txt") >>= \text -> (putStr text) instead?
18:09:03 <jadrian> so I was expecting to have
18:09:08 <juhp> but according the hslibs docs it "provides support for strict state threads"
18:09:10 <jadrian> - the apply function defined
18:09:31 <jadrian> but there is no apply function... you don't have an initial state...
18:09:36 <lodewijk> jsw: yes, also works. well, that gives me two leads then. thank you.
18:09:45 <jadrian> that seemed weird to me...
18:10:17 <jadrian> I also expected some function to access state... some generalization of the above GetX
18:10:22 <jadrian> something like:
18:10:50 <jadrian> getS :: ST s a
18:11:32 <jadrian> getS = ST(\s->(s,s))
18:11:37 <jadrian> but nope
18:11:54 <jadrian> instead it uses some kind of references to initialize the state...
18:12:01 <jadrian> just can't get it...
18:12:03 <jadrian> :(
18:13:36 <jadrian> then again... maybe that ST module is not what I think it is...
18:13:42 <juhp> hmmm. sounds like the ST you're after and the ST in hslibs are different things?
18:13:48 <jadrian> maybe...
18:14:10 <jadrian> but it's a State Transformer!
18:14:44 <jadrian> and I'm here waisting my time with this... :((
18:16:51 --- join: kepler (~kepler@adsl-81-164-115.asm.bellsouth.net) joined #haskell
18:17:15 <jadrian> hi kepler
18:17:29 <jadrian> kepler, now you must know this! :)
18:18:06 <jadrian> kepler: know anything about the ST Monad (ghc)
18:36:16 --- part: matju left #haskell
18:45:02 <smkl> x <- newSTRef 1; y <- readSTRef x; writeSTRef x (y+y);
18:45:25 <jadrian> mmmmmmm
18:46:02 <jadrian> yes... I could see it was something like that... but what I don't really understand is how to use that
18:46:30 <jadrian> do you know the "Monads for the Haskell Working Programmer" tutorial?
18:46:38 <smkl> no
18:47:02 <jadrian> well... the ST i've seen are first applyed to an initial state
18:47:17 <jadrian> this one begins with an empty state...
18:47:36 <smkl> they probably only can have one variable
18:47:49 <jadrian> that is sort of weird... I'd just like to see a simple example on how to use this... 
18:48:01 <jadrian> ever used it smkl?
18:48:10 <smkl> nope
18:48:38 <jadrian> have any idea how to use it? 
18:48:42 <jadrian> for instance
18:49:47 <jadrian> check this out
18:49:52 <jadrian> http://www.engr.mun.ca/~theo/Misc/haskell_and_monads.htm
18:50:01 <jadrian> search for: An Example
18:50:32 <jadrian> I can understand *that*
18:50:36 <jadrian> for instance
18:50:57 <jadrian> getX, getY :: StateTrans ImpState Int
18:51:00 <jadrian> getX = ST(\(x,y)-> ((x,y), x))
18:51:00 <jadrian> getY = ST(\(x,y)-> ((x,y), y))
18:51:10 <jadrian> this allow you to take part of the state...
18:51:26 <jadrian> I was expecting to have something like
18:51:47 <jadrian> getS :: ST s a
18:52:01 <jadrian> getS = ST(\s->(s,s))
18:52:13 <jadrian> to get the state...
18:52:17 <jadrian> but nope...
18:52:27 <jadrian> don't have anything like that...
18:53:02 <jadrian> I can't really understand how to use those STRefs if you don't have an initial state
18:53:26 <smkl> the initial state is to have no refs
18:54:17 --- join: kepler_ (~kepler@adsl-81-164-115.asm.bellsouth.net) joined #haskell
18:54:22 <jadrian> ok...
18:54:29 <jadrian> so let me think...
18:54:37 <jadrian> wb kepler
18:54:41 <jadrian> wb kepler_
18:54:56 <kepler_> hi
18:55:13 --- quit: kepler_ (Client Quit)
18:55:16 <jadrian> <- trying to understand the ST Monad (ghc) 
18:55:23 <jadrian> wow he's fast...
18:56:14 <jadrian> so Euclides algorithm for instance...
18:56:33 <jadrian> (a lil big but here it goes)
18:56:43 <jadrian> -- 
18:56:49 <jadrian> gcdST :: StateTrans ImpState Int
18:56:50 <jadrian> gcdST = do x <- getX
18:56:50 <jadrian>            y <- getY
18:56:50 <jadrian>            (if x == y
18:56:50 <jadrian>             then
18:56:50 <jadrian>                  return x
18:56:52 <jadrian>             else if x < y
18:56:54 <jadrian>             then 
18:56:56 <jadrian>                  do putY (y-x)
18:56:58 <jadrian>                     gcdST
18:57:00 <jadrian>             else
18:57:02 <jadrian>                  do putX (x-y)
18:57:04 <jadrian>                     gcdST)
18:57:06 <jadrian> --
18:57:10 <jadrian> greatestCommonDivisor x y = snd( applyST gcdST (x,y) )
18:57:12 <jadrian> --
18:57:34 <jadrian> in here I'd start with no refs
18:57:53 <jadrian> and I'd have to initialize a (x,y) reference...
18:59:16 <jadrian> so I'd need one function to init them, and another one with the algorithm?
19:00:49 <jadrian> and I still can't really see the diference between ST s a 
19:00:50 <kepler> you don't need an initial state with monads really...
19:00:59 <jadrian> and STRef s a
19:01:50 <jadrian> kepler: I'm just sort of confused because I've been reading the "Monads for the Working Haskell Programmer" tutorial
19:02:12 <jadrian> and now the ghc ST Monad seems to be  completely diferent
19:02:51 <jadrian> in the tutorial I'd apply the monad to an initial state
19:02:55 <jadrian> for instance 
19:03:00 <jadrian> applyST gcdST (x,y)
19:03:03 <kepler> at the lowest level, a monad is a set of operations...  all monads allow you to turn a normal value into a "monaded" value with the return statement
19:03:26 <smkl> greatestCommonDivisor x0 y0 =
19:03:27 <smkl>   runST (
19:03:27 <smkl>     do {
19:03:27 <smkl>       x <- newSTRef x0;
19:03:27 <smkl>       y <- newSTRef y0;
19:03:27 <smkl>       let
19:03:30 <smkl>         getX = readSTRef x
19:03:30 <jadrian> yes that I know
19:03:32 <smkl>         getY = readSTRef y
19:03:33 <smkl>         putX = writeSTRef x
19:03:35 <smkl>         putY = writeSTRef y
19:03:37 <smkl>         gcdST =
19:03:39 <smkl>           do x <- getX
19:03:43 <smkl>              y <- getY
19:03:45 <smkl>              (if x == y  then return x
19:03:47 <smkl>               else if x < y then
19:03:49 <smkl>               do putY (y-x)
19:03:51 <smkl>                  gcdST
19:03:53 <smkl>               else
19:03:55 <smkl>               do putX (x-y)
19:03:58 <smkl>                  gcdST)
19:04:00 <smkl>       in gcdST } )
19:04:34 <jadrian> let me see
19:10:53 --- join: ujtam (~matju@HSE-Montreal-ppp3465099.sympatico.ca) joined #haskell
19:11:52 <jadrian> mmmmmm
19:11:52 <jadrian> it is beginning to make more sense... I think...
19:12:22 --- quit: smkl (Connection reset by peer)
19:12:52 <jadrian> but not sure yet... :)
19:12:52 <jadrian> did ghc accepted this for you?
19:12:52 <jadrian> I'm getting an error msg...
19:12:54 --- join: smkl (~sami@glubimox.yok.utu.fi) joined #haskell
19:13:01 <jadrian> wb smkl
19:13:10 <jadrian> hi ujtam
19:13:20 <jadrian> smkl: I think it is starting to make more sense :)
19:13:25 <jadrian> smkl: but not sure yet
19:13:44 <jadrian> smkl: did ghci accepted the code for you (getting an error msg here)
19:14:28 --- join: xbill (wli@DOMINIA.MIT.EDU) joined #haskell
19:14:35 <smkl> i used hugs
19:14:35 --- nick: ujtam -> matju
19:14:35 <jadrian> hi xbill
19:14:41 <xbill> re
19:15:26 <jadrian> "The last statment in a 'do' construct must be an expression"
19:15:48 <jadrian> opss
19:15:51 <jadrian> forget it
19:15:52 <jadrian> :)
19:18:00 <jadrian> the weird part is this naming thing...
19:18:13 <jadrian> the naming of the referencies...
19:18:46 <jadrian> imagine I want to keep track of some ocurrence
19:19:04 <jadrian> and I want to increment some 'variable' each time something happens
19:19:28 <jadrian> I can see how I'd do that in this example
19:19:53 <jadrian> but imagine that inside this GCD function I call other functions
19:20:17 <jadrian> and inside those functions I want to increment that variable...
19:20:21 <jadrian> how do I do that
19:20:32 <jadrian> I don't know the name of the references...
19:22:56 <jadrian> for instance
19:24:30 <smkl> you just need to define them so that the references are in scope
19:24:35 <jadrian> genAlgorithm pop
19:24:35 <jadrian>     runST (
19:24:35 <jadrian>      do {
19:24:35 <jadrian>       mutations <- newSTRef 0;
19:24:35 <jadrian>       (chrom1, chrom2) <- select pop
19:24:36 <jadrian>       (new1, new2)     <- crossover (chrom1, chrom2)
19:24:38 <jadrian>       return(new1, new2)
19:24:40 <jadrian> 	})
19:24:50 <jadrian> ok this is not really a genetic algorithm... 
19:24:52 <jadrian> but
19:25:13 <jadrian> I start with 0 mutations
19:25:16 <jadrian> select 2 guys
19:25:19 <jadrian> and cross them
19:25:24 <smkl> or pass the references as argument
19:25:27 <jadrian> in the crossover some mutation could happen
19:25:36 <jadrian> mmmm
19:26:00 <jadrian> but what I'm trying to do is *avoid* passing this data as arguuments
19:26:39 <jadrian> the whole purpose of the state monad is to me able to just use some function to set a new state inside my functions
19:27:10 <jadrian> I want to have something like,
19:27:53 <jadrian> crossover :: (Chrom,Chrom) -> State (Chrom, Chrom)
19:28:13 <jadrian> the state will be updated during crossover
19:28:15 <jadrian> that means
19:28:31 <jadrian> if there was mutation, I'll increment some mutation reference I have
19:29:27 <jadrian> the infinite randoms list of rand numbers will be updated (meaning that I get and remove values from them)
19:30:05 <jadrian> That's the purpose of using that ST... I can keep track of stuff without passing all the data as arguments
19:30:20 <jadrian> I just can't see how to access the references from other functions
19:30:29 <smkl> if defining the functions like in my example is no good then use a usual state transformer
19:32:00 <jadrian> well, from your example I now understand better how this ST works... was not even understanding what the runST was for :)
19:32:21 <jadrian> but *this* is the usual state transformer
19:32:30 <jadrian> as this is the one in both Ghc and Hugs
19:32:41 <jadrian> so you got to be able to do this somehow
19:33:53 <smkl> i meant the simple one used in monad examples
19:34:21 <jadrian> yes I know... but I'd really like to understand how this one is supposed to work...
19:34:35 <jadrian> and this is probably optimized so works better...
19:34:45 <jadrian> and I wanted to learn how to do this the right way...
19:34:48 --- part: matju left #haskell
19:36:28 <jadrian> well 4:40 am here...
19:36:34 <jadrian> 3:40 am even
19:36:45 <jadrian> better get some sleep and think about it tomorrow
19:36:46 <jadrian> :)
19:37:57 <jadrian> bye and thanks smkl :)
19:38:06 --- quit: jadrian ("Client Exiting")
20:16:56 --- part: jsw left #haskell
20:20:48 --- join: kepler_ (~kepler@adsl-81-161-191.asm.bellsouth.net) joined #haskell
20:21:11 --- quit: kepler (Read error: 104 (Connection reset by peer))
22:12:22 --- quit: kepler_ (Read error: 110 (Connection timed out))
23:00:02 --- quit: shapr ("time to go to work")
23:59:59 --- log: ended haskell/02.01.06