19:51 <+robbe> dus pakt (+)
19:51 <+robbe> (+) :: Num a => a -> a -> a
19:53 -!- Topic for #infogroep: Welkom op #infogroep, het kanaal van de studentenkring voor computerwetenschappers op de VUB. 1ste bachelors: kijk ook eens op #igperma voor specifieke studiehulp.
19:53 -!- Topic set by Ichabod [~Arty@missioncontrol.be] [Wed Nov  6 23:30:26 2013]
19:53 [Users #infogroep]
19:53 [@angryzor    ] [@K        ] [@treynaer] [+klx_    ] [+sven       ] [ rubdos]
19:53 [@endymion    ] [@mattje   ] [+Bennit  ] [+Numlock ] [ bart       ] [ scoeri]
19:53 [@ErgonomicRbt] [@omega    ] [+BitChar ] [+peanut  ] [ check      ]
19:53 [@fearless    ] [@pewpewpew] [+bomma   ] [+reinout ] [ Interesting]
19:53 [@Ichabod     ] [@rAyrton  ] [+Botje-  ] [+robbe   ] [ m1dnight   ]
19:53 [@Jaspn_GRR   ] [@Spartam  ] [+Ian     ] [+schudder] [ m1dnight_  ]
19:53 -!- Irssi: #infogroep: Total of 32 nicks [13 ops, 0 halfops, 12 voices, 7 normal]
19:53 <+robbe> hela
19:53 < m1dnight_> damnit
19:53 <+robbe> welk stuk van mennen uitleg hebde gemist :p
19:53 -!- Irssi: Join to #infogroep was synced in 19 secs
19:53 < m1dnight_> vanaf "dus pakt"
19:53 < m1dnight_> heb ik niets meer :p
19:54 <+robbe> Your paste can be seen here: http://bpaste.net/show/150025/
19:54 < m1dnight_> ik zat hier als een koe te kijken "alle, wa doet em nu"
19:54 <+robbe> ping als ge mee zijt
19:54 < m1dnight_> ping
19:54 < check> m1dnight_: ping timeout
19:55 <+robbe> silly check
19:55 <+robbe> instance Functor [] -- Defined in `GHC.Base'
19:56 <+robbe> met andere woorden lijsten zijn functors
19:56 < m1dnight_> omdat [] een type constructor is
19:56 <+robbe> die 1 argument pakt
19:56 < m1dnight_> idd
19:57 < m1dnight_> en fmap (+42) is dus een functie die normaal alleen werkt op Int instances
19:57 <+robbe> en dus die fmap (+42) is voor lijsten exact hetzelfde
19:57 < m1dnight_> (- fmap)
19:57 <+robbe> als map
19:57 < m1dnight_> maar met fmap kan ik die dus toepassen op typeconstructors die Int aangenomen hebben
19:57 < m1dnight_> hence, de andere categorieen?
19:57 <+robbe> ge moet nie naar diene int zien
19:58 <+robbe> das collateral van het feit da ik daar 42 heb gezet
19:58 < m1dnight_> ja idd
19:58 <+robbe> als ik (+een_koe) doe gaat exact hetzelfde verhaal op
19:58 <+robbe> instance Functor Maybe -- Defined in `Data.Maybe'
19:58 <+robbe> maar uw lifted function werkt dus op alles wa een functor is
19:59 < m1dnight_> I see
19:59 < m1dnight_> ik denk dat'k het snap
19:59 <+robbe> en 't is dus de functor die bepaalt wat het wilt zeggen om een functie in zijn categorie uit te voeren
19:59 <+robbe> voor een lijst is da "pas functie toe op elk element"
19:59 < m1dnight_> aaahh!
19:59 < m1dnight_> ja :)
19:59 < m1dnight_> zo ben ik mee!
19:59 <+robbe> voor een Maybe is da "pas functie toe op de x van Just x, ofwel Nothing"
19:59 < m1dnight_> ik was verward met "map"
20:00 < m1dnight_> oke oke!
20:00 < m1dnight_> ik zen mee!
20:00 < m1dnight_> robbe: merci e! :)
20:00 <+robbe> ge mapt geen functie over een lijst
20:00 <+robbe> ge mapt een functie tussen categorieen

20:01 < m1dnight_> holy shit
20:01 < m1dnight_> sorry :p
20:01 < m1dnight_> (kging uw uitleg opslaan :D)
20:01 <+robbe> verzet uwe rechtse knop is naar de middelste in putty
20:01 <+robbe> gij kieken
20:01 <+robbe> :)
20:01 < m1dnight_> ja idd, maar op desktop was dat nog niet gebeurd :p
20:02 <@Ichabod> ...
20:02 < check> [You suddenly realize it is unnaturally quiet.]
20:02 <+robbe> dus ge doet da nu :p
20:02 < m1dnight_> I did!
20:02 < m1dnight_> :D
20:02 <+robbe> ma dus
20:03 <+robbe> instance Functor (Either a) -- Defined in `Data.Either'
20:03 <+robbe> geef zelf is in woorden hoe da die (+42) zou werken voor Either
20:05 < m1dnight_> fmap (+42) op (Either a) is ofwel uw f toepassen op (Left a) ofwel op (Right b), en dat produceert een datatype van (Either a c) waar c dus b kan zijn
20:06 <+robbe> "waar c dus b kan zijn" ?
20:06 < m1dnight_> ah, aangezien ge met (+42) zit is dat dus sowieso een Either a Int, maar ik wil zggen dat uw fmap een arbitrair type kan produceren
20:07 < m1dnight_> ah nee, een Either a b , met (Num b)
20:07 <+robbe> en waarom restricteert ge enkel b
20:07 <+robbe> een value van type Either a b is ofwel Left a, ofwel Left b
20:08 < m1dnight_> aja indeed, ge kunt van a ook naareen ander type gaan
20:08 < m1dnight_> grrr :p
20:08 < m1dnight_> brainfuck
20:09 <+robbe> haal die "lijst-map" uit uw hoofd
20:09 <+robbe> en denk ik termen van uw functie die ge lift
20:09 <+robbe> mijn functie die op platte waarden werkt, werkt nu op Maybe a b dingen
20:10 <+robbe> als ik mijn lifted functie toepas op een Maybe a b ding, dan pas ik die ofwel toe op een Left a, ofwel op een Right b
20:10 <+robbe> als ik een Left a heb, dan is het resultaat Left (a+42)
20:10 < m1dnight_> (+42) fmappen op een (Either a) is ofwel (+42) toepassen op Left a, ofwel op Right b. Het resultaat van (+42) op (Left a) is dan een (Left (f a)), same goes for (Right b)
20:10 <+robbe> als ik een Left b heb, dan is het resultaat Right (b+42)
20:10 < m1dnight_> indeed
20:10 <+robbe> da ziet er hetzelfde uit als wa ik net zei :)
20:10 < m1dnight_> inderdaad
20:10 < m1dnight_> ik denk dat ik mee ben
20:10 < m1dnight_> nu enkel nog
20:11 < m1dnight_> het type van (Right (f b)) is dan (Either a <type dat (f b) uitspuwt>)
20:11 <+robbe> (+ 42) :: Num a => a -> a
20:12 <+robbe> aangezien da ge die functie ofwel toepast op een Left a; of een Right b, zal dus zowel a en b (van Either a b) een instance moeten zijn van Num
20:12 <+robbe> aangezien da de functie alleen maar gedefinieerd is voor waarden die een instance zijn van Num
20:12 < m1dnight_> aja oke
20:12 < m1dnight_> goe, dan ben ik mee denk ik! :)
20:13 < m1dnight_> even laten bezinken nu :D
20:13 <+robbe> fmap (+42) $ Left 12 :: (Num b, Num a) => Either a b
20:13 < m1dnight_> ahja inderdaad!
20:13 < m1dnight_> :D
20:13 < m1dnight_> was ff twijfelen over welk type het dan zou zijn voor de left als ge f toepast op right
20:13 < m1dnight_> but it makes sense
20:14 < m1dnight_> oke :)
20:14 < m1dnight_> GOE!
20:14 < m1dnight_> robbe: dikke merci!