--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/paste/paste.17882	Mon Apr 22 07:40:06 2013 +0000
@@ -0,0 +1,301 @@
+2008-02-21.txt:22:54:08: <oerjan> that is: fmap fst (minViewWithKey . snd . split currentLineNo $ currentProgram).  i think.
+2008-06-07.txt:04:25:30: <augur> positive == return, happy == fmap?
+2008-06-07.txt:04:26:14: <augur> happy is fmap i think
+2008-06-07.txt:04:27:58: <augur> happy has to be fmap
+2008-06-07.txt:04:29:32: <augur> fmap is (a -> b) -> f a -> f b
+2008-06-07.txt:04:29:46: <augur> fmap is (a -> b) -> f a -> f b
+2008-10-26.txt:00:12:07: <Asztal> I think it definitely makes things more readable in the case of things like `isPrefixOf` and maybe `fmap`
+2009-02-16.txt:17:25:38: <ehird> > loeb x = fmap (\a -> a (loeb x)) x
+2009-02-27.txt:18:15:46: <ehird> 18:15 ehird: @pl fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-02-27.txt:18:15:46: <ehird> 18:15 lambdabot: fmap (fmap (fmap fmap)) fmap
+2009-02-27.txt:18:15:50: <ehird> fmap calculus
+2009-02-27.txt:18:16:25: <ais523> what does fmap do?
+2009-02-27.txt:18:16:37: <ehird> 18:15 ehird: :t fmap
+2009-02-27.txt:18:16:38: <oerjan> adding 4 fmaps gives the same after a while
+2009-02-27.txt:18:16:49: <ehird> for which fmap = (.)
+2009-02-27.txt:18:17:00: <ehird> for which fmap = map
+2009-02-27.txt:18:17:17: <ehird> ideally, map and (.) wouldn't exist and fmap would be called (.)
+2009-02-27.txt:18:17:54: <oerjan> fmap = liftM for monads
+2009-02-27.txt:18:18:04: <ehird> lambdabot used to have (.) as fmap
+2009-02-27.txt:18:18:58: <ehird> 18:17 HugoDaniel has left IRC ("fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap vim")
+2009-02-27.txt:18:19:41: <ehird> ehird: @. type pl fmap . fmap . fmap fmap fmap fmap (fmap . fmap fmap) . fmap fmap fmap
+2009-03-24.txt:17:08:31: <ehird> "Or even how to implement Haskell's ap/<*> (translated painstakingly to Java) in terms of fmap, return, and join (this is legally considered torture in 49 states)"
+2009-04-10.txt:20:58:46: <Deewiant> ehird: fmap (Const . read) (many1 digit)
+2009-05-15.txt:20:28:14: <Deewiant> findFixPoint f = fmap snd . find (uncurry (==)) . (zip `ap` tail) . iterate f
+2009-06-23.txt:20:36:36: <ehird> @pl \x -> foo `fmap` bar x
+2009-06-23.txt:20:36:37: <lambdabot> (foo `fmap`) . bar
+2009-06-24.txt:15:18:37: <Warrigal> <*> looks like fmap.
+2009-06-24.txt:15:22:31: <Warrigal> s/map/fmap/
+2009-06-24.txt:15:27:09: <lambdabot> f <$> a = fmap f a
+2009-06-24.txt:15:27:28: <Warrigal> Woo, it's fmap.
+2009-06-24.txt:18:00:14: <ehird> pikhq: also, "fmap" is both (.) and map, for functions and lists
+2009-06-24.txt:18:00:16: <ehird> > fmap succ [1,2,3]
+2009-06-24.txt:18:00:23: <ehird> > fmap (fmap succ succ) [1,2,3]
+2009-06-24.txt:19:15:27: <oerjan> l >>= f = join (fmap f l)
+2009-06-24.txt:19:16:12: <oerjan> fmap = map, since the functor instances agree (parametricity makes it hard/impossible to have more than one Functor instance)
+2009-06-24.txt:19:16:32: <Gracenotes> I'm pretty sure fmap [] has one sane instance :)
+2009-06-25.txt:16:31:39: <ehird> :t fmap
+2009-06-25.txt:16:31:51: <ehird> but that's what fmap is :P
+2009-06-25.txt:16:36:58: <ehird> @src (->) fmap
+2009-06-25.txt:16:36:58: <lambdabot> fmap = (.)
+2009-06-25.txt:16:38:20: <pikhq> I know you can use fmap in order to confuse people instead of ., though...
+2009-06-25.txt:16:38:41: <ehird> pikhq: it is the opinion of many that map and (.) should not exist, and that fmap should be called (.)
+2009-06-26.txt:01:09:10: <oerjan> !haskell import System.Random; main = sequence_ . replicate 200 $ fmap (putStr . (["hurf","durf","hurd"]!!)) randomRIO (0,2)
+2009-06-26.txt:05:24:26: <pikhq> > fmap ord ['\0'..]
+2009-06-26.txt:05:27:58: <pikhq> > fmap chr $ (+) <$> (fmap ord ['\0'..]) <*> cycle [1]
+2009-06-26.txt:05:30:49: <pikhq> > fromZipList $ fmap chr $ (+) <$> (fmap ord ['\0'..]) <*> cycle [1]
+2009-06-26.txt:05:31:16: <pikhq> > getZipList $ zipList (fmap chr $ (+) <$> (fmap ord ['\0'..])) <*> zipList $ cycle [1]
+2009-06-26.txt:05:31:35: <pikhq> > getZipList $ ZipList (fmap chr $ (+) <$> (fmap ord ['\0'..])) <*> ZipList $ cycle [1]
+2009-06-26.txt:05:32:21: <immibis> @help fmap
+2009-06-26.txt:05:32:31: <pikhq> > fmap chr $ fmap (+1) $ fmap ord ['\0'..]
+2009-06-26.txt:05:33:19: <pikhq> > fmap . fmap . fmap chr (+1) ord ['\0'..]
+2009-06-26.txt:05:33:54: <gracenotes> *FMAP* *FMAP* *FMAP* *FMAP* *FMAP* *FMAP*
+2009-06-27.txt:02:16:43: <oerjan> however, m >>= return . f  == fmap f m
+2009-06-27.txt:02:18:02: <oerjan> no, fmap
+2009-06-27.txt:02:18:07: <lambdabot> f <$> a = fmap f a
+2009-06-27.txt:02:48:24: <oerjan> = fmap ((*198.838782).(*1079252848.8)) [1..]
+2009-07-09.txt:20:00:36: <lambdabot> Data.Traversable fmapDefault :: Traversable t => (a -> b) -> t a -> t b
+2009-07-09.txt:20:00:36: <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
+2009-07-12.txt:00:15:15: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:15:53: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:16:03: <Gracenotes> ..however it takes some time to infer longer fmap chains
+2009-07-12.txt:00:16:14: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:17:33: <Gracenotes> oddly enough, it seems that any chain of fmaps always produces djinn functions in the original order
+2009-07-12.txt:00:17:54: <ehird> :t t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:18:07: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:18:13: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:18:18: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:19:16: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:19:40: <ehird> :t fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap fmap
+2009-07-12.txt:00:19:41: <pikhq> I'm renaming fmap.
+2009-07-12.txt:00:20:38: <ehird> :t let (.) = fmap in (.) . . (.)
+2009-07-12.txt:00:20:43: <ehird> :t let (.) = fmap in (.) . (. (.))
+2009-07-12.txt:00:21:05: <ehird> :t let (.) = fmap in (.) . (. (.)) . (((.) . ((.) . (.)) .) . ((.) .) . (.)
+2009-07-12.txt:00:21:29: <Gracenotes> me no likey (.) = fmap
+2009-07-12.txt:00:21:31: <ehird> :t let (.) = fmap in (.) . ((.)) . ( ((.) . ((.) . (.)) .) . ((.) .)) . (.)
+2009-07-12.txt:00:21:39: <ehird> Gracenotes: but (.) and map are useless; they're just fmap
+2009-07-12.txt:00:21:47: <pikhq> @src (->) fmap
+2009-07-12.txt:00:21:48: <lambdabot> fmap = (.)
+2009-07-12.txt:00:21:54: <ehird> @src [] fmap
+2009-07-12.txt:00:21:54: <lambdabot> fmap = map
+2009-07-12.txt:00:22:22: <ehird> @unpl let (.) = fmap in (.) . ((.)) . (((.) . ((.) . (.)) .) . ((.) .)) . (.)
+2009-07-12.txt:00:22:22: <lambdabot> let { (.) = fmap} in (\ z b c f h i l o s -> z (b c f (h i l o s)))
+2009-07-12.txt:00:22:29: <ehird> @unlet let (.) = fmap in (.) . ((.)) . (((.) . ((.) . (.)) .) . ((.) .)) . (.)
+2009-07-12.txt:00:24:00: <pikhq> It's like fmap on the monads!
+2009-07-12.txt:01:01:29: <lambdabot> fmap
+2009-07-12.txt:01:09:45: <pikhq> :t ap `fmap` ($)
+2009-07-12.txt:20:33:28: <ehird> pikhq: Cale used to have lambdabot lie about stuff. It had (.) = fmap
+2009-07-12.txt:20:34:05: <pikhq> fmap should definitely be called fmap.
+2009-07-12.txt:20:34:28: <pikhq> It's just a special case of fmap.
+2009-07-15.txt:13:25:56: <ehird> > let (.) = fmap in head . words "aalso evel"
+2009-07-16.txt:16:18:31: <lambdabot> Data.Traversable fmapDefault :: Traversable t => (a -> b) -> t a -> t b
+2009-07-16.txt:16:18:31: <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
+2009-07-16.txt:16:18:33: <ehird> oh it's fmap
+2009-07-16.txt:18:51:13: <pikhq> @. hoogle t fmap
+2009-07-16.txt:18:51:38: <pikhq> @. hoogle type fmap
+2009-08-15.txt:00:55:24: <pikhq> Now if you had asked about the difference between fmap and functional composition, I could say something.
+2009-08-15.txt:00:55:32: <pikhq> Like, say, fmap being a generalisation.
+2009-08-17.txt:04:52:36: <ehird> getArgs >>= mapM readFle >>= fmap (map parse)
+2009-08-17.txt:04:53:32: <ehird> though (do args <- getArgs; contents <- mapM readFile args; parses <- fmap (map parse)) works too, but is tedious
+2009-08-17.txt:04:54:05: <pikhq> Bah. fmap (map parse) <<= mapM readFile <<= getArgs
+2009-10-03.txt:21:54:47: <pikhq> (/fmap/map/liftM2...)
+2009-12-26.txt:13:13:52: <augur> xs >>= (return . f) == fmap f xs
+2009-12-26.txt:13:17:48: <AnMaster> augur, what is fmap?
+2009-12-26.txt:13:18:20: <soupdragon> you can define fmap usint >>= and return
+2009-12-26.txt:13:18:45: <augur> fmap is i think probably somethat you can think of as like
+2009-12-26.txt:13:20:06: <augur> and so in order to be a Monad you also have to be a Functor which means you have to have fmap defined.
+2009-12-26.txt:13:20:58: <augur> fmap id x = x
+2009-12-26.txt:13:21:19: <augur> fmap (f . g) x = fmap f (fmap g x)
+2009-12-26.txt:13:22:36: <AnMaster> fmap takes a lambda and whatever it is to map over?
+2009-12-26.txt:13:22:59: <soupdragon> fmap f m = do x <- m ; return (f x)
+2010-01-05.txt:16:19:41: <oerjan> it's the same as fmap or <$>
+2010-01-07.txt:01:01:49: <Asztal> (>>=)  is SelectMany(), fmap is Select(), return is different for each one.
+2010-01-09.txt:16:00:59: <ehird> I wish this were Caleskell and (.) = fmap
+2010-01-09.txt:16:01:07: <ehird> Hey, maybe I could just define (.) = fmap
+2010-01-09.txt:16:01:10: <Deewiant> You can set (.) = fmap easily
+2010-01-09.txt:16:03:03: <pikhq> Deewiant: Caleskell makes (.)=fmap.
+2010-01-09.txt:16:55:46: <ehird>   fmap f (Strict a) = strictorlazy (f $! a)
+2010-01-09.txt:16:55:46: <ehird>   fmap f (Lazy a)   = lazy (f a)
+2010-01-09.txt:17:04:12: <ehird>       fmap f x = pure f <*> x
+2010-01-15.txt:17:47:58: <ehird> main = putStr =<< (fmap concat $ getArgs >>= mapM readFile)
+2010-01-15.txt:17:53:13: <ehird> main = putStr =<< (fmap (reverse . concat) $ getArgs >>= mapM readFile)
+2010-02-06.txt:14:25:07: <ehird> anyway, {| 2 + {3 ÷ x} |} is nicer to write than fmap (2 +) (3 ÷ x)
+2010-02-06.txt:14:38:27: <ehird> which is even generaler than o = fmap, i think
+2010-02-06.txt:14:38:48: <MissPiggy> fmap and o are quite different thuogh
+2010-02-06.txt:14:39:02: <MissPiggy> fmap should just be map
+2010-02-06.txt:14:39:14: <ehird> ok, that doesn't allow . = fmap
+2010-02-13.txt:18:06:09: <alise> Functor f a = <fmap : (a -> b) -> f a -> f b>
+2010-02-13.txt:18:07:19: <alise> Functor_List a = <fmap f x = map f x>
+2010-03-07.txt:22:45:57: <alise_> Presumably along the lines of the elimination given by fmap above.
+2010-04-02.txt:21:46:27: <pikhq> Functors are objects where fmap makes sense.
+2010-04-02.txt:23:13:47: <oerjan> Quadrescence: as of now you only need to implement (>>=) and return to make a Monad.  and haskell doesn't currently have a feature that allows you to deduce a _superclass_ method (Functor's fmap) from that, that's what this class something feature would do
+2010-04-05.txt:04:42:35: <oerjan> const () `fmap`
+2010-05-02.txt:23:38:38: <alise__> *Main> fmap biFro [0..10]
+2010-05-02.txt:23:42:30: <alise__> *Main> fmap decrush [0..20]
+2010-05-08.txt:23:15:03: <alise_> No, a monad is fmap, join and unit!
+2010-06-20.txt:01:29:39: <CakeProphet> I wonder why they didn't just make map and fmap the same function.
+2010-06-20.txt:01:36:24: <CakeProphet> I was wondering because the semantics of fmap only applies f to Right values
+2010-06-27.txt:03:32:32: <CakeProphet> ah. fmap?
+2010-07-12.txt:23:41:47: <aliseiphone> !haskell :t fmap fmap fmap
+2010-07-12.txt:23:41:48: <EgoBot> fmap fmap fmap :: (Functor ((->) (a -> b)), Functor f1, Functor f) =>
+2010-07-20.txt:21:32:22: <pikhq> AnMaster: It's infix fmap.
+2010-07-27.txt:03:26:04: <Mathnerd314> oerjan: x `subset` y = and (fmap (`elem` y) x
+2010-08-06.txt:17:52:09: <alise> *Main> fmap fromRational (approxE 10000)
+2010-08-09.txt:17:31:31: <alise> fmap id = id
+2010-08-09.txt:17:31:34: <alise> fmap (f.g) = fmap f . fmap g
+2010-08-10.txt:22:51:37: <oerjan> Phantom_Hoover: x >>= return . f  = fmap f x   (or liftM f x)
+2010-08-10.txt:22:54:18: <Phantom_Hoover> oerjan, hang on, fmap can work without bind, obviously.
+2010-11-02.txt:11:19:21: <elliott> unify (H (Conj xs)) (S (Conj ys)) = fmap concat . sequence $ zipWith unify xs ys
+2010-11-02.txt:11:37:31: <elliott>   case catMaybes $ map (\(l,r) -> fmap ((,) r) (unify l x)) ys of
+2010-11-02.txt:11:39:05: <elliott> unify (H (Conj xs)) (S (Conj ys)) = fmap concat . sequence $ zipWith unify xs ys
+2010-11-02.txt:11:45:24: <elliott>   case mapMaybe (\(l,r) -> fmap ((,) r) (unify l x)) ys of
+2010-11-30.txt:16:27:04: <elliott>   map (\(Rule lhs rhs) -> (rhs,) `fmap` sab lhs t) $ rs
+2010-11-30.txt:17:08:49: <elliott>   case catMaybes . map (\(Rule lhs rhs) -> (rhs,) `fmap` sab lhs t) $ rs of
+2010-12-11.txt:21:58:04: <elliott> join . fmap return == id
+2010-12-11.txt:21:58:04: <elliott> join . join == join . fmap join
+2010-12-11.txt:21:58:20: <elliott> oerjan: wait do you need fmap to do a monad? doesn't join/return suffice
+2010-12-11.txt:22:00:32: <Phantom_Hoover> (>>= f) = join (fmap f), yes?
+2010-12-11.txt:22:18:00: <elliott> hm so wait how do you do bind in terms of fmap and join?
+2010-12-11.txt:22:18:10: <elliott> x >>= f = join (fmap f x)
+2010-12-11.txt:22:23:26: <Phantom_Hoover> Indeed, (>>=) = flip $ join . fmap
+2010-12-11.txt:22:25:45: <oerjan> (>>=) = flip $ (join .) . fmap
+2010-12-11.txt:22:27:03: <Phantom_Hoover> bind = (join .) . flip fmap
+2010-12-11.txt:22:30:26: <Phantom_Hoover> elliott, how's fmap defined for Tree?
+2010-12-11.txt:22:48:04: <Phantom_Hoover> elliott, fmap (A B : Set) (f : A -> B).
+2010-12-11.txt:22:48:35: <Phantom_Hoover> fmap [elided or not actually there depending on what's set] id is a type error.
+2010-12-11.txt:22:49:03: <elliott> Phantom_Hoover: OK, please give me the full definition of fmap.
+2010-12-11.txt:22:49:13: <elliott> Phantom_Hoover: OK, please give me the full definition of fmap.
+2010-12-11.txt:22:49:36: <elliott> Phantom_Hoover: OK, please give me the full definition of fmap.
+2010-12-11.txt:22:50:00: <Phantom_Hoover> Fixpoint fmap (A B : Set) (f : A -> B) (t : tree A) : tree B := [elided].
+2010-12-11.txt:22:51:57: <Phantom_Hoover> Essentially, I'm told that fmap id is an error as id : ID rather than * -> *.
+2010-12-11.txt:22:52:26: <elliott> Phantom_Hoover: You might want to try using {A B : Set} in fmap.
+2010-12-11.txt:22:53:40: <elliott> Coq < Axiom fmap : forall (A B : Set) (f : A -> B) (t : tree A), tree B.
+2010-12-11.txt:22:53:40: <elliott> fmap is assumed
+2010-12-11.txt:22:53:48: <elliott> fmap_id
+2010-12-11.txt:22:55:33: <elliott> Coq < Definition fmap_id (A : Set) (t : tree A) : tree A := fmap A A (id (A:=A)) t.
+2010-12-11.txt:22:55:33: <elliott> fmap_id is defined
+2010-12-11.txt:22:58:34: <elliott> Phantom_Hoover: When you say "fmap A A id t", it can't infer what the value of A is in id's type, (forall A, A -> A).
+2010-12-16.txt:16:54:35: <Phantom_Hoover> ais523, erm... Functor and fmap?
+2010-12-16.txt:16:55:02: <ais523> in fact, liftM and fmap are IIRC the same function
+2010-12-18.txt:22:50:11: <Phantom_Hoover> Anything's a monad if you can get return, join and fmap working on it!
+2010-12-18.txt:22:51:04: <elliott> fmap seems obvious.
+2010-12-18.txt:22:53:32: <Deewiant> Phantom_Hoover: join . fmap join = join . join
+2010-12-18.txt:22:54:16: <Deewiant> = join . fmap return
+2010-12-29.txt:19:43:14: <Phantom_Hoover_> Surely fmap f = (pure f <*>)
+2010-12-29.txt:19:53:50: <Phantom_Hoover_> Where fmap f = (pure f <*>)
+2011-01-09.txt:05:46:51: <oerjan> elliott: well it's fmap/liftM + <=<  of course
+2011-01-09.txt:05:48:00: <oerjan> :t (\f x -> fmap f . x)
+2011-01-09.txt:05:49:20: <oerjan> lambdabot still defines (.) = fmap :D
+2011-01-09.txt:05:49:47: <elliott> oerjan: but yes, of course it defines (.) = fmap, as specified by the Caleskell Report
+2011-01-09.txt:05:50:26: <elliott> fmap fmap fmap
+2011-01-09.txt:05:51:43: <oerjan> indeed it _is_ fmap fmap fmap
+2011-01-09.txt:05:52:03: <elliott> fmap fmap fmap fmap fmap fmap fmap
+2011-01-09.txt:05:52:26: <oerjan> elliott: that reiterates after four fmaps
+2011-01-14.txt:18:01:51: <lambdabot> ([(c1', s1), (c2', s2)] ++) `fmap` apply c xs
+2011-01-14.txt:18:16:10: <oerjan> 19:04  lambdabot> ([(c1', s1), (c2', s2)] ++) `fmap` apply c xs
+2011-01-22.txt:15:25:44: <oerjan> in which case, mdo iorefs <- (: iorefs) `fmap` newIORef whatever should work, i don't think you even need unsafeInterleaveIO for that
+2011-01-23.txt:20:01:41: <lambdabot> NB: In lambdabot,  (.) = fmap
+2011-01-23.txt:20:03:28: <elliott> olsner: imo map needs to become fmap
+2011-01-29.txt:03:37:37: <oerjan> :t \f x -> fmap ($ x) f
+2011-01-29.txt:03:38:03: <elliott> @pl \f x -> fmap ($x) f
+2011-01-29.txt:03:38:03: <lambdabot> flip (fmap . flip id)
+2011-01-29.txt:03:38:16: <elliott> let flip = flip (fmap . flip id)
+2011-01-29.txt:03:52:56: <oerjan> :t \f x -> fmap ($x) f
+2011-01-29.txt:03:55:23: <oerjan> :t (\f x -> Data.Traversable.traverse f x) `asTypeOf` (\f x -> fmap ($x) f)
+2011-01-29.txt:03:58:11: <oerjan> :t (\f x -> Data.Traversable.sequenceA f x) `asTypeOf` (\f x -> fmap ($x) f)
+2011-01-31.txt:02:26:15: <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
+2011-01-31.txt:02:32:30: <elliott> fmap fmap fmap
+2011-01-31.txt:02:35:11: <oerjan> :t let map f (Left x) = fmap f x; map f (Right b) = Nothing in map
+2011-01-31.txt:02:35:51: <oerjan> :t let map f (Left x) = Just $ fmap f x; map f (Right b) = Nothing in map
+2011-01-31.txt:02:36:47: <oerjan> :t let map f (Left x) = Just $ fmap f x; map f (Right False) = Nothing; map f (Right True) = [] in map
+2011-01-31.txt:02:36:55: <oerjan> :t let map f (Left x) = Just $ fmap f x; map f (Right False) = Nothing; map f (Right True) = Just [] in map
+2011-02-03.txt:23:03:52: <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
+2011-02-03.txt:23:03:52: <lambdabot> Control.Monad fmap :: Functor f => (a -> b) -> f a -> f b
+2011-02-03.txt:23:04:04: <elliott> @pl flip fmap
+2011-02-03.txt:23:04:04: <lambdabot> flip fmap
+2011-02-03.txt:23:09:18: <lambdabot> (`fmap` pUL) . (:<) =<< pSimpleUL
+2011-02-07.txt:00:40:10: <Deewiant> Use fmap and ap and @unpl
+2011-02-07.txt:01:16:26: <lambdabot> Data.Traversable fmapDefault :: Traversable t => (a -> b) -> t a -> t b
+2011-02-07.txt:01:16:26: <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
+2011-02-07.txt:12:20:21: <lambdabot> (popVec >>=) . (return .) =<< fmap (flip poke) pop
+2011-02-08.txt:11:41:32: <oerjan> > let (<$) = fmap . const; infixl 1 <$ in do x <- y <$ Just z ; return x
+2011-02-08.txt:11:41:44: <oerjan> > let (<$) = fmap . const; infixl 1 <$ in do x < - y <$ Just z ; return x
+2011-02-08.txt:18:13:26: <copumpkin> elliott: I dunno, which do you typically want to fmap?
+2011-02-09.txt:19:12:46: <elliott> :t fmap
+2011-02-17.txt:19:50:32: <elliott> oerjan: `fmap` instead of <$>? srsly?
+2011-02-17.txt:19:57:28: <oerjan> <elliott> oerjan: `fmap` instead of <$>? srsly? <-- if i start using <$>, i'll soon want Applicative notation, and HP's Parsec doesn't have an instance, and basically i don't even want to bother to try because it makes me annoyed
+2011-03-11.txt:17:35:39: <oerjan> flip and fmap, are there any others like that...
+2011-04-13.txt:22:57:26: <newsham> oerjan: you could use `fmap` and `ap` instead of <$> and <*> if you wanted to stay in monad
+2011-04-13.txt:22:57:57: <oerjan> also you mean liftM not fmap
+2011-04-13.txt:22:58:16: <newsham> ?type (liftM, fmap)
+2011-05-12.txt:16:10:36: <ais523> I know I tend to define fmap for my own structures if it fits
+2011-05-12.txt:16:14:24: <ais523>     fmapM :: Monad m => (a -> m b) -> (t a) -> m (t b)
+2011-05-12.txt:16:14:35: <ais523> I think I needed to cross fmap and mapM
+2011-05-14.txt:10:18:01: <oerjan> synonym for fmap
+2011-05-14.txt:10:18:03: <CakeProphet> fmap. applies a function to a Functor instance. All monads are functors.
+2011-05-14.txt:10:20:45: <oerjan> it's the monad equivalent of fmap, existing for stupid "missing subclassing" reasons
+2011-06-06.txt:22:47:03: <CakeProphet> ah so <$ is fmap.const
+2011-06-06.txt:22:47:20: <elliott> :t fmap.const
+2011-06-06.txt:22:48:27: <elliott> because I think we could deduce that (fmap . const) and (<$) are the same by just the types
+2011-06-06.txt:22:48:35: <lambdabot>     fmap        :: (a -> b) -> f a -> f b
+2011-06-06.txt:22:49:00: <oerjan> and i think it applies to fmap.const = (<$)
+2011-06-06.txt:22:49:25: <elliott> \a b -> fmap _ b
+2011-06-06.txt:23:04:50: <elliott> > fmap (take 9) (some (Just 9))
+2011-06-06.txt:23:21:33: <elliott>         fmap f (ZipList xs) = ZipList (map f xs)
+2011-06-13.txt:00:52:51: <elliott_> oh its actually cofmap :: (a -> b) -> acc b -> acc a :P
+2011-06-13.txt:00:54:19: <elliott_> > fmap succ (9,9)
+2011-06-13.txt:01:04:35: <elliott_>   cofmap :: (a -> b) -> cof b -> cof a
+2011-06-13.txt:01:04:39: <elliott_>   cofmap f (Flip g) = Flip (g . f)
+2011-06-15.txt:00:59:32: <monqy> not fmap?
+2011-06-15.txt:00:59:52: <monqy> (I was expecting it to be a synonym of fmap)
+2011-06-15.txt:00:59:55: <oerjan> i _thought_ they'd also made map a synonym for fmap, but i must have misremembered
+2011-06-15.txt:01:40:59: <oerjan> it's rather stupid to have map, fmap, <$>, liftM
+2011-06-15.txt:01:41:43: <lambdabot> f <$> a = fmap f a
+2011-06-15.txt:01:41:54: <Patashu> so it's just infix fmap
+2011-06-15.txt:01:41:58: <Patashu> why not just use `fmap` then
+2011-06-15.txt:01:42:07: <oerjan> Patashu: it can work on functors too, in fact it did before Haskell 98 revision, when fmap = map
+2011-06-15.txt:01:42:55: <oerjan> it separated map from fmap, making map work just for lists.
+2011-06-15.txt:01:45:07: <monqy> just use fmap
+2011-06-15.txt:01:47:56: <monqy> e.g. for a Functor instance of a Monad, fmap f = (>>= return . f)
+2011-06-15.txt:01:48:27: <lambdabot>     fmap        :: (a -> b) -> f a -> f b
+2011-06-15.txt:01:49:59: <Patashu> (+) <$> [1,2] <*> [10,20] becomes <*> ( fmap (+) [1,2] ) ( [10,20] )
+2011-06-15.txt:01:50:54: <Patashu> > (<*>) ( fmap (+) [1,2] ) ( [10,20] )
+2011-06-21.txt:11:45:59: <elliott> :t ?f.?g `fmap` x
+2011-06-21.txt:11:46:02: <elliott> :t ?f.?g `fmap` ?x
+2011-06-21.txt:11:46:04: <elliott> :t ?f . ?g `fmap` ?x
+2011-06-21.txt:11:46:05: <lambdabot>         cannot mix `.' [infixr 9] and `fmap' [infixl 9] in the same infix expression
+2011-06-21.txt:12:04:15: <elliott> <elliott> ?pl \f x -> join (fmap f x)
+2011-06-21.txt:18:53:39: <elliott_> ?pl (\(r,n) -> ifuckinghateyouass r) `fmap` I.zip it countWords
+2011-06-21.txt:18:53:40: <lambdabot> (ifuckinghateyouass . fst) `fmap` I.zip it countWords
+2011-06-21.txt:18:53:47: <elliott_> ?pl flip fmap
+2011-06-21.txt:18:53:47: <lambdabot> flip fmap
+2011-06-21.txt:18:54:33: <lambdabot> Prelude fmap :: Functor f => (a -> b) -> f a -> f b
+2011-06-21.txt:18:54:33: <lambdabot> Control.Monad fmap :: Functor f => (a -> b) -> f a -> f b
+2011-06-21.txt:19:07:04: <elliott_>   where opt field ctr = \it -> uncurry (setL field . Just) `fmap` I.zip it ctr
+2011-06-21.txt:19:32:27: <elliott_> option field ctr = \it -> uncurry (setL field . Just) `fmap` I.zip ctr it
+2011-06-21.txt:19:39:53: <oerjan> elliott_: perhaps that fmap is also building thunks of what to apply
+2011-06-23.txt:19:22:47: <elliott_> > foldlM (\r x -> if even x then (9:) `fmap` r else Nothing) [] [0,0,9]
+2011-06-25.txt:01:03:21: <monqy> :t fmap id
+2011-07-01.txt:10:21:49: <Deewiant> ?src Either fmap
+2011-07-01.txt:10:21:49: <lambdabot> fmap _ (Left x) = Left x
+2011-07-01.txt:10:21:50: <lambdabot> fmap f (Right y) = Right (f y)
+2011-07-03.txt:02:53:37: <elliott>    fmap = liftM
+2011-07-03.txt:06:59:08: <elliott>   fmap f (T ph pf pr) = T  ( \  k -> ph ( k .f ))
+2011-07-03.txt:07:22:14: <elliott> you can't do that fmap
+2011-07-03.txt:07:26:33: <elliott> so basically I have fmap... for lenses :)
+2011-07-03.txt:07:27:05: <elliott> yep, what I have is (.), aka generalised fmap :D
+2011-07-03.txt:07:48:51: <elliott>   fmap concat (sequence (concatMap (\(n,_,_) -> [ [d| foo = 9 |] ]) oks))
+2011-07-03.txt:08:16:00: <elliott>   mapM (\(n,_,_) -> funD (transform n) [clause [] (normalB ([|Data.Lens.Lens|] `appE` varE n `appE` lamE [varP _f, varP _x] (recUpdE (varE _x) [(\x->(n,x)) `fmap` [|$(varE _f) ($(varE n) $(varE _x))|]]))) []]) oks
+2011-07-03.txt:08:35:31: <elliott>   mapM (\(n,_,_) -> funD (transform n) [clause [] (normalB ([|Data.Lens.Lens|] `appE` varE n `appE` lamE [varP _f, (asP _x (recP nn [return (n,VarP _y)]))] (recUpdE (varE _x) [(\x->(n,x)) `fmap` [|$(varE _f) $(varE _y)|]]))) []]) oks
+2011-07-03.txt:11:04:01: <olsner> CakeProphet: you can think of it as fmap (fmap (flip fmap fmap) fmap) fmap, if composition is confusing :)
+2011-07-03.txt:11:13:35: <olsner> also, (.).(.) = the boobies combinator = fmap fmap fmap
+2011-07-03.txt:11:16:18: <CakeProphet> but... fmap = (.) for functions right?
+2011-07-03.txt:11:17:41: <olsner> yes, one functor instance has fmap = (.), and to make matters better lambdabot has (.) defined as fmap
+2011-07-03.txt:11:24:14: <Phantom_Hoover> <olsner> yes, one functor instance has fmap = (.), and to make matters better lambdabot has (.) defined as fmap
+2011-07-03.txt:11:33:41: <CakeProphet> :t fmap
+2011-07-05.txt:00:39:22: <elliott> :t liftM2 (:) (return ?x) (return `fmap` copy ?y)
+2011-07-05.txt:00:39:24: <elliott> :t liftM2 (:) (return ?x) (return `fmap` ?copy ?y)
+2011-07-05.txt:00:39:32: <elliott> :t \x y -> liftM2 (:) (return x) (return `fmap` ?copy y)
+2011-07-05.txt:00:39:43: <elliott> ?pl liftM2 (:) (return x) (return `fmap` ?copy y)
+2011-07-05.txt:00:39:48: <elliott> ?pl \x y -> liftM2 (:) (return x) (return `fmap` copy y)
+[too many lines; stopping]