00:00:00 --- log: started haskell/02.02.22
02:34:15 --- quit: cuelebre (Remote closed the connection)
02:45:21 --- join: Yurik (~yrashk@gw.telcos.net.ua) joined #haskell
03:18:04 --- join: ChoJin (~ask@cha213245038031.chello.fr) joined #haskell
03:21:36 --- join: cuelebre (~cuelebre@212.85.32.125) joined #haskell
06:09:06 --- quit: smkl (Remote closed the connection)
06:09:25 --- join: smkl (~sami@glubimox.yok.utu.fi) joined #haskell
06:10:29 --- join: ski (~md9slj@fraggel29.mdstud.chalmers.se) joined #haskell
06:45:03 --- quit: Yurik (Remote closed the connection)
07:14:10 --- join: Yurik (~yrashk@gw.telcos.net.ua) joined #haskell
07:17:09 <Yurik> re
08:04:16 * Grimace goes fiddle inside his computer. Back later.
08:04:23 --- part: Grimace left #haskell
08:08:00 <cuelebre> someone worked with HaXML ?
10:19:13 --- quit: Yurik (Remote closed the connection)
13:41:10 --- join: creichen (~jameson@p50817F11.dip.t-dialin.net) joined #haskell
13:41:12 <creichen> Hi!
13:41:25 <Heffalump> hi
13:49:04 <creichen> I'm currently trying to generate ghc-compileable haskell sources from its *.hsc files; however, I don't have hsc2hs available for that particular platform (and I haven't managed to get it to work with hugs yet, as it seems to be missing a Config.hs). Any ideas/suggestions?
13:51:07 <Heffalump> from what's hsc files?
13:51:41 <creichen> ghc 5.02.2 (sorry!)
13:52:29 <Heffalump> hmmm, would cpp be good enough?
13:53:33 <creichen> I tried that, but it inserted a number of '#' directives (short for #line, IIRC), which could be removed relatively trivially...
13:53:57 <Heffalump> cpp | grep then :-)
13:54:04 <creichen> ...but it also included a number of system headers with structs and typedefs, which I don't believe ghc will compile.
13:54:05 * Heffalump cna't be any more helpful than that, sorry
13:54:08 <Heffalump> ah.
13:54:26 <Heffalump> copy the headers from that system to a platform where hsc2hs does work?
13:56:36 <creichen> Hmm, might work; might require some minor patching to hsc2hs, though...
13:56:53 <creichen> I'll try that. Thanks for the suggestion!
14:14:02 * Logan needs some gif tool for haskell.
16:04:36 --- quit: creichen ("Connection reset by beer")
17:01:10 --- join: foonley (~nikhouri@zeus.ecs.syr.edu) joined #haskell
17:02:07 <foonley> anyone here?
17:04:43 <ski> no discussion here currently :(
17:05:13 <foonley> heh
17:05:15 <ski> perhaps you have something to ask/discuss ?
17:05:26 <foonley> I have a question, actually
17:05:32 <ski> i'm all ears
17:05:39 <foonley> heh thanks
17:05:43 <ski> err, eyes, that is
17:06:41 <foonley> ok here's what I'm trying to write: a function that takes two lists, zips them then applies a given function 'f' on each tuple, returning a list
17:06:52 <ski> ok
17:07:02 <foonley> so:
17:07:16 <ski> your trying to write it yourself ? to understand how to do it ?
17:07:25 <foonley> zapp f x y = map (\(u,v) -> (f u v)) (zip x y)
17:07:28 <foonley> trying to write it myself
17:07:43 <foonley> I get type errors, confusing me
17:08:04 <ski> hmm
17:08:12 <foonley> zapp :: (Bool -> Bool) -> [Bool] -> [Bool] -> [Bool]
17:08:18 <ski> Bool ?
17:08:22 <foonley> yah
17:08:46 <foonley> really what I want it to do is take two lists of bools and run an operation on both lists
17:08:52 <foonley> so like I could xor two bit strings
17:08:58 <foonley> or and them or or them, whatever
17:09:01 <ski> it seem to me that zapp :: ((a,b) -> c)) -> [a] -> [b] -> [c]
17:09:30 <foonley> how?
17:09:58 <ski> no
17:10:00 <ski> oops
17:10:11 <foonley> heh
17:10:15 <ski> it should be zapp :: (a -> b -> c) -> [a] -> [b] -> [c
17:10:25 <ski> with an ] at the end
17:10:27 <Logan> Yeah.
17:10:31 <foonley> you and hugs agree completely
17:10:38 <foonley> but I don't see how?
17:10:58 --- quit: ChoJin ("bye !!!")
17:11:01 <ski> so my built-in type-inferencer did finally work it correctly out
17:11:10 <foonley> heh it seems so
17:11:24 <ski> what don't you understand
17:11:32 <foonley> aaaaaaarrrrgh
17:11:34 <foonley> nevermind
17:11:37 <foonley> I am an idiot
17:11:53 <ski> no, i don't think so. maybe perhaps a newbie
17:11:54 * foonley is blinded by a flash of the obvious
17:12:33 <ski> do you wan't it restricted to work only with Bool or is this form acceptable ?
17:12:50 <foonley> bool is the ultimate use for it
17:13:08 <ski> restricted to Bool it becomes, zapp :: (Bool -> Bool -> Bool) -> [Bool] -> [Bool] -> [Bool]
17:13:11 <foonley> really I just wrote it as a separate function when I was trying to get it to work in a  'where ...' for something else
17:13:12 <foonley> yah
17:13:18 <foonley> thanks
17:13:20 <ski> ok
17:13:52 <ski> actually this function is a part of the Prelude but under a different name, wanna know which ?
17:14:01 <foonley> oh man
17:14:03 <foonley> really?
17:14:07 <ski> yes
17:14:10 <foonley> yes, definately
17:14:36 <ski> i guess it has been deemed sufficiently useful to be put in the Prelude
17:14:44 <foonley> heh
17:14:45 <ski> well, it's zipWith !
17:15:03 <foonley> bleh I probably should have remembered this from my course in Haskell last year
17:15:06 <foonley> thanks, ski
17:15:29 <ski> so you can say e.g. zipWith (&&) (foobar 1 2) [True,True,False]
17:15:36 <foonley> is there an xor defined in the prelude?
17:15:37 <foonley> yep
17:15:45 <ski> hmm
17:15:49 <foonley> yeah that was one thing I was worried about
17:16:06 <foonley> inorder operators
17:16:10 <ski> i think there's no explicit xor operator but /= *is* xor for booleans !
17:16:50 <foonley> uhrk so it is
17:17:11 <ski> so zipWith (/=) [False,False,True,True] [False,True,False,True] should yield [False,True,True,False]
17:17:22 <foonley> ski you're a genius
17:17:31 <foonley> what can I say
17:17:49 <ski> but if you want another xor symbol you can do something like this :
17:18:09 <ski> (^^) :: Bool -> Bool -> Bool
17:18:20 <ski> (^^) = (/=)
17:18:27 <foonley> nice
17:18:39 <ski> or say x ^^ y = x /= y if you prefer that
17:18:53 <foonley> yah I had one defined myself, I'm probably duplicating work all over the place
17:19:09 <ski> (IIRC in C ^ is bit-xor, though there is no boolean-xor in C :( )
17:20:54 <foonley> thanks ski
17:21:00 <ski> no prob.
17:21:21 <foonley> this is actually for a crypto class
17:21:31 <ski> aha. ok.
17:21:34 <foonley> I'm trying to write the SHA-1 hash in haskell
17:21:52 <ski> i'm not familiar with SHA-1 hash :(
17:22:11 <ski> (though i know what a hash function is)
17:22:17 <foonley> yah
17:23:13 <foonley> anyway, thanks for all your help, ski
17:23:27 --- quit: foonley ("foonley has no reason")
17:30:00 <ski> hmm, i am thinking about a technique for coding some things, and i wonder if it has any particular name ..
17:35:13 --- part: ski left #haskell
17:42:01 --- join: ski (~md9slj@fraggel29.mdstud.chalmers.se) joined #haskell
17:42:45 * ski back after nosing a little around in some other channels
17:52:51 --- part: ski left #haskell
23:17:18 --- quit: smkl (Remote closed the connection)
23:17:46 --- join: smkl (~sami@glubimox.yok.utu.fi) joined #haskell
23:59:59 --- log: ended haskell/02.02.22