00:00:00 --- log: started haskell/02.03.09
01:12:35 --- join: ChoJin (~ask@cha213245038031.chello.fr) joined #haskell
01:51:11 --- join: shapr (~user@p-c2fbabf7.easy.inet.fi) joined #haskell
03:19:18 --- join: Yurik (~yrashk@gw.telcos.net.ua) joined #haskell
03:25:00 <shapr> hi Yurik 
03:26:02 <Yurik> shapr: hi
03:26:19 --- quit: shapr ("xemacs yeehaaa!")
04:02:53 --- quit: xbill ("Leaving")
05:08:38 --- quit: clausen (Remote closed the connection)
11:36:28 * LoganH is trying to figure out how to define a Church integer in Haskell so that he can define a mapping from a Church integer to a von Neumann integer.
11:37:47 <LoganH> I suppose it's not possible.
11:38:25 <Heffalump> you could just define it as a lambda term, surely?
11:38:54 <LoganH> No, it's not quite that simple.
11:39:51 <LoganH> You need a function that transforms [] to [[]], then transforms [[]] to [[], [[]]], then [[], [[]]] to [[], [[]], [[], [[]]]].  And so on. :P
11:41:01 <Heffalump> \xs -> []:map (\ys->[ys]) xs
11:42:15 <LoganH> Doesn't work, I'm afraid.
11:42:27 <Heffalump> oh, I misread what you said above
11:42:30 <LoganH> I get errors like: Occurs check: cannot construct the infinite type: a = [a]
11:42:44 <Heffalump> errm, I don't when I type that function in
11:42:59 <LoganH> Something like [[], [[]]] probably isn't even valid.
11:43:04 <Heffalump> yes, it is
11:43:08 <LoganH> So the problem is I'm trying to do an impossible transformation. :P
11:43:11 <LoganH> Hmm.
11:43:17 <LoganH> Ok, it's a list of type [a]
11:43:26 <Heffalump> [[[a]]]
11:44:42 <LoganH> How can I define a Church integer generating function that takes functions of type a -> [a]?
11:44:56 <Heffalump> I can't remember how Church integers are generated
11:45:48 <Heffalump> but I doubt you can, since IIRC they apply the input function n times, and you can't give a type to a function of type a->[a] applied n times
11:46:28 <LoganH> A Church integer is a function that applies a given function to a given expression n times.
11:46:40 <LoganH>         church n = c
11:46:40 <LoganH>                    where
11:46:40 <LoganH>                    c f x = if n == 0 then x else c' f (f x)
11:46:40 <LoganH>                            where
11:46:41 <LoganH>                            c' = church (n-1)
11:46:43 <LoganH> (from foldoc)
11:46:50 <LoganH> unchurch c = c (+1) 0
11:47:25 <Heffalump> so a -> [a] is a silly type for the input functions
11:56:48 <LoganH> I'm curious as how to define church to support this transformation, or use what I have already to do it.
12:34:35 <ChoJin> c f x | n == 0 = c' f (f x) where c' = church (n-1)
12:34:49 <ChoJin> isn't beautiful with | ?
12:35:01 <ChoJin> instead of 'if'
12:35:06 <ChoJin> oups
12:35:12 <ChoJin> c f x | n == 0 = x
12:35:12 <ChoJin> :)
12:35:28 <ChoJin> c f x | otherwise = c' f (f x)
13:14:29 --- join: clausen (~andrew@c17997.eburwd3.vic.optusnet.com.au) joined #haskell
13:18:56 * clausen isn't grokking functors
13:19:06 <clausen> anyone giving free lessons?  (or a URL?)
13:41:21 --- join: DLid (hidden-use@host80-1-72-245.no-dns-yet.ntli.net) joined #haskell
13:42:07 <DLid> does anyone know how i could write a recursive function which takes an int value and turns it into a binary list?
13:42:25 <DLid> im new to haskell and struggling a bit
13:42:33 <clausen> what's a binary list?
13:42:44 <DLid> well i mean into a binary value
13:42:46 <DLid> in a list
13:42:52 <clausen> ah
13:43:00 <clausen> liek:
13:43:02 <clausen> like:
13:43:04 <DLid> so 13 would give a list [1,1,0,1]
13:43:10 <clausen> so, it's a list of integers?
13:43:11 <DLid> but also i want the list backwards
13:43:13 <clausen> [Int]
13:43:14 <clausen> ?
13:43:18 <DLid> i think that would be easier
13:43:30 <clausen> sounds easy:
13:43:34 <DLid> well i have defined a type Bit = Int
13:43:39 <clausen> toBinary :: Int -> [Int]
13:43:47 <DLid> yeah done that bit
13:43:58 <clausen> toBinary 0 = [0]
13:44:04 <clausen> toBinary 1 = [1]
13:44:43 * clausen thinks
13:45:05 <DLid> i thought you would have to do something like 13 mod 2
13:45:09 <DLid> if the number was 13
13:45:11 <clausen> hmmm, you need to keep track of which place you are up to
13:45:21 * clausen was trying to be too sneaky
13:45:26 <clausen> I think you need accumulator recursion
13:45:39 <DLid> how do i do this?
13:45:47 <clausen> hang on a sec
13:47:19 <ChoJin> how can we do a bit mask in haskell ?
13:47:31 <ChoJin> & ?
13:47:41 <clausen> think so
13:47:54 <clausen> apparantly not
13:48:17 <clausen> google it?
13:49:07 <ChoJin> toBinary n = (n & 1) : toBinary (n >> 1) (if >> is bit shift and & is bit mask
13:49:17 <ChoJin> toBinary 0 = [0]
13:49:31 <ChoJin> and same thing for 1, I think
13:49:40 <ChoJin> well, I am new in haskell, so ...
13:50:01 <DLid> hmm, i was thinking much simpler
13:50:28 <DLid> such as if ns `mod` 2 then some_function_with_1 else some_function_with_0
13:51:22 <DLid> clausen: what do you suggest?
13:52:25 <clausen> ChoJin: still working on it...
13:52:41 <clausen> oops DLid
13:54:03 <clausen> got it :)
13:54:11 <clausen> toBinary :: Int -> [Int]
13:54:12 <clausen> toBinary 0 = [0]
13:54:12 <clausen> toBinary x = if x `mod` 2 == 0 then
13:54:12 <clausen>                 0:(toBinary (x `div` 2))
13:54:12 <clausen>              else
13:54:12 <clausen>                 1:(toBinary (x `div` 2))
13:54:36 <DLid> thx, ill try that
13:54:56 <clausen> it puts an extra 0 in front
13:55:04 <clausen> which is a bit yuck
13:55:11 <clausen> (like you said, it's reversed too)
13:56:18 <ChoJin> just add toBinary 1 = [1]
13:56:19 <ChoJin> :)
13:56:34 <ChoJin> mm there is a problem
13:56:43 <ChoJin> oups, no :)
13:58:13 * clausen ponders better ways of writing that
13:58:48 <clausen> toBinary :: Int -> [Int]
13:58:48 <clausen> toBinary 0 = [0]
13:58:48 <clausen> toBinary x = (x `mod` 2):(toBinary (x `div` 2))
14:12:36 <ChoJin> toBinary x = x `mod` 2:toBinary $ x `div` 2
14:12:51 <ChoJin> maybe with some () :)
14:14:20 <clausen> hehe
14:37:09 --- join: dave1 (hidden-use@host80-1-72-245.no-dns-yet.ntli.net) joined #haskell
14:37:10 --- quit: DLid (Read error: 104 (Connection reset by peer))
14:37:20 --- nick: dave1 -> DLid
14:38:08 <DLid> ok, i have another problem...
14:38:16 <DLid> im making a make8 function...
14:38:26 <DLid> which make8 :: [Bit] -> [Bit]
14:38:33 <DLid> where type Bit = Int
14:39:15 <DLid> and what i want is to get the length of the make8 and if the list is longer than 8, chop it down to just 8
14:39:19 <DLid> so i have this code...
14:39:29 <DLid> make8 ms = if length ms > 8 then
14:39:32 <DLid> 	     make8(init ms)
14:39:32 <DLid>            else
14:39:35 <DLid> [0]
14:39:44 <DLid> however, it keeps returning 0
14:39:51 <DLid> could somebody help please
14:40:04 <clausen> hmmm
14:40:27 <clausen> what's init?
14:40:44 <DLid> init removes the last element from a non-empty list
14:41:16 <clausen> anyway, presumebly you want to add something to the list?
14:41:24 <clausen> on the recursive call
14:41:43 * clausen playing table tennis
14:41:44 <clausen> bbiab
14:42:13 <DLid> well, if the length is less than 8
14:42:28 <DLid> add 0's to the front of the list until it is of length 8
14:42:44 <DLid> i mean, add 0's to the front sorry
14:43:29 <DLid> is init not defined in the library?
14:45:00 <DLid> anyone?
14:51:56 --- quit: DLid ()
15:05:59 --- join: DLid (hidden-use@host80-1-72-245.no-dns-yet.ntli.net) joined #haskell
15:06:06 <DLid> anyone here?
15:11:38 --- quit: DLid ()
15:34:12 * clausen prods again: anyone know about functors?
15:58:47 * clausen found a really good introduction to category theory :)
15:58:59 <clausen> http://wwwhome.cs.utwente.nl/~fokkinga/mmf92b.html
16:11:10 * Heffalump knows a bit about them
16:11:34 <clausen> cool :)
16:11:43 <clausen> well, I think this paper should explain everything
16:11:50 <clausen> just, I'm trying to understand functors, as used in haskell
16:11:58 <Heffalump> as in the type class?
16:12:01 <Heffalump> or in general?
16:12:02 <clausen> like, these pieces of code appear very Deep and Meaningful TM
16:12:05 <clausen> Heffalump: the type class
16:12:47 <clausen> instance Functor Maybe where
16:12:47 <clausen>     fmap f Nothing  = Nothing
16:12:47 <clausen>     fmap f (Just x) = Just (f x)
16:12:49 <Heffalump> ok, so the only point about the type class (and really functors in general) is that it's a means of "lifting" a function
16:12:54 <clausen> instance Functor [] where
16:12:54 <clausen>     fmap = map
16:12:58 <Heffalump>   fmap :: (b -> c) -> a b -> a c
16:13:02 <clausen> instance Functor ((->) a) where
16:13:02 <clausen>     fmap = (.)
16:13:15 <Heffalump> so all that means is given a function from b to c, you can get one from Foo b to Foo c
16:13:22 <Heffalump> for appropriate Foo
16:14:07 <clausen> hmmm
16:14:19 <clausen> what is Foo in this context?
16:14:24 <clausen> say, [b] -> [c] ?
16:14:31 <Heffalump> yep, that's a nice simple example
16:14:55 <Heffalump> Foo could be a type constructor, or, more generally, anything that takes a type and gives you another type
16:15:08 <Heffalump> so (->) a takes type b and gives you type a->b
16:15:23 <Heffalump> so the fmap there does (b->c) -> ((a->b) -> (a->c))
16:15:29 <Heffalump> and it can be defined by
16:16:19 <clausen> interesting
16:16:22 <Heffalump> fmap (f :: (b->c)) (g :: (a->b)) (x :: a) = f (g x)
16:16:28 <Heffalump> which simplifies to fmap = (.)
16:16:42 <Heffalump> it all comes from the types
16:17:46 <clausen> :: ?
16:17:57 * clausen never seen it used this way
16:20:46 <Heffalump> I think that's valid syntax
16:20:52 <Heffalump> I'm just saying that that parameter has that type
16:21:01 <Heffalump> maybe I've been writing SML for too long :/
16:21:20 <clausen> hehe
16:21:38 <clausen> I think you have to write it like this:
16:22:01 <clausen> fmap :: (b->c) -> (a->b) -> (a -> c)  (???)
16:22:19 <clausen> fmap f g x = f (g x)
16:22:20 <clausen> or something
16:25:03 <Heffalump> probably
16:25:22 <Heffalump> I wasn't really trying to write valid Haskell anyway, just illustrate what was going on
16:25:23 <clausen> fmap f g = (.)
16:25:27 <clausen> yep
16:25:31 <clausen> oops
16:25:33 <clausen> fmap = (.)
16:25:33 <Heffalump> no, fmap = (.)
16:25:34 <clausen> ;)
16:25:36 <Heffalump> yeah :-)
16:25:48 <Heffalump> the point is that once you've decided the type, there's actually only one definition that works
16:25:56 <clausen> right
16:26:02 <clausen> and you use fmap to get it
16:26:13 <Heffalump> no, IM there's only one definition of fmap that works
16:26:17 <clausen> ?
16:26:33 <Heffalump> instance Functor ((->) a) where
16:26:40 <Heffalump> given that you're trying to write that instance
16:26:43 <clausen>  fmap (+1) [1..5]
16:26:45 <clausen> works
16:26:48 <Heffalump> the only *possible* way to write fmap is fmap = (.)
16:26:57 <clausen> ?
16:27:02 <Heffalump> [or something equivalent]
16:27:11 <clausen> isn't it different for each category?
16:27:19 <clausen> (or set?)
16:27:25 <Heffalump> yes, hence the "given that you're trying to write that instance" bit of what I said
16:27:27 <clausen> (object?)
16:27:35 <Heffalump> category
16:30:23 <clausen> is there an identity category?
16:34:55 <clausen> oops, an identity constructor
16:35:03 <clausen> no, that makes no sense
16:36:47 <clausen> Prelude> fmap (*2) (Just 5)
16:36:48 <clausen> Just 10
16:37:06 * clausen beginning to grok this now :)
16:42:02 --- nick: Yurik -> Yurik[sleeping]
16:44:51 <clausen> Heffalump: so, can you give me an example of fmap on functions?
16:44:56 <clausen> (in the sense of (.))
16:52:43 <clausen> Prelude> (.) (*2) (+1) 5
16:52:44 <clausen> 12
16:52:51 <clausen> Prelude> (fmap) (*2) (+1) 5
16:52:51 <clausen> ERROR: Illegal Haskell 98 class constraint in inferred type
16:52:51 <clausen> *** Expression : fmap (flip (*) 2) (flip (+) 1) 5
16:52:51 <clausen> *** Type       : (Num a, Functor ((->) a)) => a
16:53:11 <clausen> instance Functor ((->) a) where
16:53:11 <clausen>     fmap = (.)
16:54:27 <Heffalump> is Functor ((->) a) in the Prelude?
16:55:25 <clausen> yes
16:55:48 <clausen> (the last two lines, yes)
16:55:51 <Heffalump> it's not in my Prelude..
16:57:12 <Heffalump> and yes, there is an identity constructor, data Foo a = Foo a 
16:57:19 <Heffalump> but you have to define the instance manually
16:58:39 <clausen> thanks
16:58:44 <clausen> strange there's no standard
16:58:51 --- quit: ChoJin ("bye !!!")
16:58:51 <clausen> wait
16:58:54 <clausen> it's not identity
16:59:02 <clausen> because Foo a != Bar a
16:59:15 <clausen> I think "id" is better
16:59:43 <Heffalump> ok, there isn't a single definitive identity constructor
16:59:57 <Heffalump> AFAIK you can't write instance Functor (\a -> a)
16:59:59 <Heffalump> where a is a type
17:00:04 <Heffalump> or anything like that
17:00:09 <clausen> anyway
17:00:16 <clausen> can you figure out why my fmap didn't work?
17:00:17 <Heffalump> so you have to fake it with a dummy constructor
17:00:27 <clausen> (fmap) (*2) (+1) 5
17:00:35 <Heffalump> I get the same error but I expect it cos Functor ((->) a) isn't in my prelude
17:00:43 <clausen> add it?
17:01:09 <Heffalump> just did so
17:01:14 <Heffalump> (not to my prelude, but another file)
17:01:17 <Heffalump> Main> (fmap) (*2) (+1) 5
17:01:17 <clausen> ;)
17:01:17 <Heffalump> 12
17:01:21 <clausen> wow
17:01:30 <clausen> so it looks like a hugs bug
17:01:34 <Heffalump> and same with +98
17:01:40 <Heffalump> Version: February 2001
17:01:42 <Heffalump> is mine
17:01:56 * clausen has feb2000
17:02:07 <Heffalump> dec 2001 is fine too
17:02:12 <Heffalump> I don't think I have feb 2000 anywhere
17:02:21 <clausen> it's what's in conectiva linux
17:02:30 <clausen> and I haven't upgraded
17:02:49 <Heffalump> oh, /me finds it
17:03:36 <Heffalump> nope, works even with Feb 2000.
17:03:46 <Heffalump> mercury[~]% cat foo.hs
17:03:46 <Heffalump> instance Functor ((->) a) where
17:03:46 <Heffalump>    fmap = (.)
17:04:24 <clausen> weird
17:04:34 <Heffalump> what exactly are you doing?
17:04:35 <clausen> I'll stick the instance definition in a test script...
17:04:43 <clausen> Prelude> (fmap) (*2) (+1) 5
17:04:48 <clausen> from vanilla prelude
17:04:56 <clausen> (which DOES include that instance definition)
17:05:09 <Heffalump> and you're sure it's loading the same prelude file you're checking for it?
17:05:19 <clausen> no
17:05:25 <clausen> good point ;)
17:06:32 <clausen> ok, works in my test script now
17:06:37 <clausen> anyway, it's strange it's not in the prelude
17:11:10 <Heffalump> there's a lot of compromises in what did and didn't go into that, I think
17:11:38 <clausen> you'd expect that you'd put in the functor defs for either everything or nothing...
17:16:37 <Heffalump> hmm, but the others are more generally useful in some sense, I think that one is more of academic interest
17:17:09 <clausen> none of them seem particularly useful
17:17:57 <Heffalump> lists, maybe and IO are
17:18:02 <Heffalump> cos they're Monads too
17:18:18 <clausen> ah
17:18:28 <Heffalump> and people write utility monad code that doesn't depend on a particular monad
17:18:39 <Heffalump> I don't *think* ((->) a) is a monad
17:19:40 <Heffalump> it'd need to have something of type (a->b) -> (b -> (a->c)) -> (a->c)
17:19:43 <Heffalump> so actually I think it is
17:19:57 <Heffalump> not sure what use it is though
17:24:17 <Heffalump> (f >>= g) a = g (f a) a
17:30:11 <Heffalump> doh, it's a Reader monad
21:36:21 --- nick: Yurik[sleeping] -> Yurik
22:32:03 --- quit: clausen ("send all money to /dev/clausen")
23:59:59 --- log: ended haskell/02.03.09