Feb. 22, 2012 -- some omissions and contractions of the literal logs.

00:30:40	<eyebloom>	Instead of f x y z you could write f _ _ z
00:31:24	<rasfar>	eyebloom, this is amazing, you have hit upon the language extension I just started implementing an hour ago
00:31:45	<rasfar>	underscores and all...
00:31:45	<eyebloom>	You know what they say about great minds.
00:32:17	<rasfar>	maybe we'll find out whether there's any need.
00:33:44	<rasfar>	i was just looking to see if such an extension already exists, but it appears not (so far)
00:37:51	<eyebloom>	As syntactic sugar it would be a lot cleaner looking then a lambda a flip or even an explicit infix.
00:40:16	<eyebloom>	message me if you start working on this.
00:40:26	<rasfar>	fair enough! «email sent»

00:31:12	<quintessence>	:t flip
00:31:13	<lambdabot>	forall (f :: * -> *) a b. (Functor f) => f (a -> b) -> a -> f b
00:32:13	<cmccann>	:t flip . fmap flip
00:32:14	<lambdabot>	forall (f :: * -> *) a (f1 :: * -> *) b. (Functor f, Functor f1) => f (f1 (a -> b)) -> a -> f (f1 b)
00:32:24	<cmccann>	:t flip . fmap Prelude.flip
00:32:28	<lambdabot>	forall (f :: * -> *) a a1 c. (Functor f) => f (a1 -> a -> c) -> a -> f (a1 -> c)
00:32:29	<cmccann>	argh
00:32:34	<cmccann>	:t flip <<< fmap Prelude.flip
00:32:35	<lambdabot>	forall (f :: * -> *) a a1 c. (Functor f) => f (a1 -> a -> c) -> a -> f (a1 -> c)
00:32:44	<cmccann>	:t Prelude.flip <<< fmap Prelude.flip
00:32:45	<lambdabot>	forall a b a1 c. (a -> a1 -> b -> c) -> b -> a -> a1 -> c
00:32:56	<cmccann>	:t Prelude.flip <<< fmap Prelude.flip <<< fmap (fmap Prelude.flip)
00:32:56	<lambdabot>	forall a b a1 a2 c. (a -> a1 -> a2 -> b -> c) -> b -> a -> a1 -> a2 -> c
00:33:32	*	cmccann has a type-hackery generalized flip that does the kind of argument rotation as the above functions

00:31:15	<shachaf>	(\x y -> f x y z)
00:32:15	<dolio>	Vetoed.
00:32:18	<mzero>	if the function takes two arguments, say foo a b and you want to apply the b (leaving a function that takes a) then idiomatic Haskell is to write (`foo` 7)
00:32:30	<shachaf>	I second dolio's veto.
00:33:44	<mzero>	if you want more, it is idiomatic to use a lambda, which is generally easier than all this flipyness: (\a b -> fixMyThirdArg a b 42)
00:34:13	<tikhonjelvis>	flipyness is a good word
00:34:22	<mzero>	:-)
00:34:24	<eyebloom>	truthiness
00:45:43	<mzero>	gosh - I think the rarity of needing to partially apply a function to some argument than the first or second is such that it isn't worth complicating the language at all
00:45:55	<mzero>	practically, this just doesn't come up in my code base that often
00:47:53	<mzero>	wow - all this to avoid computer science's smallest lambda syntax? rlly?

00:46:01	<shachaf>	The obvious solution is to replace every _ with (\x->x).
00:46:15	<shachaf>	{-# LANGUAGE CPP #-} #define _ (\x->x)

00:36:42	<nand`>	let apFst = id; apSnd = flip; alThd f c = \a b -> f a b c; ...
00:36:52	<nand`>	foo `apThd` 42

00:38:19	<dolio>	I've used languages with it, and it leads to people writing unclear code.
00:38:43	<dolio>	map (foo (g _) x) (h _)
00:38:45	*	rasfar attends to dolio carefully...
00:38:47	<quintessence>	scala?
00:38:52	<dolio>	Yes.
00:38:51	<glguy_>	Unclear code? Yup, Haskell already supports that
00:39:09	<eyebloom>	:) so does every language.
00:39:44	<quintessence>	I think the problem in scala is more that it's hard to see the scope of the (implicit) lambda
00:40:22	<dolio>	foo (g _) =?= foo $ g _
00:40:58	<glguy_>	Factor supports that as a library
00:41:06	<quintessence>	Something like (\-> f _ 10 _) would be a little less ambiguous
00:41:26	<rwbarton>	Mathematica has this goofy Foo[a, #, c] & syntax
00:42:39	<rwbarton>	where & is like quintessence's \-> but in postfix form
00:44:27	<dolio>	Matter of fact, what does "map (foo (g _) x) (h _)" mean?
00:45:29	<nand`>	\a b -> map (foo (g a) x) (h b) maybe?
00:45:48	<shachaf>	How do you figure out where to put the lambda?
00:45:55	<nand`>	I didn't. I took a wild guess
00:46:01	<nand`>	that's the problem

00:46:16	<dolio>	nand`: I can tell you, that's not what the equivalent Scala code means.
00:46:30	<rwbarton>	could you show the actual equivalent Scala code?
00:46:56	<dolio>	h(_).map(foo(g(_))(x))
00:47:21	<glguy_>	it burns us!
00:47:27	<dolio>	Drink that in.
00:47:30	<nyingen>	urk
00:48:06	<dolio>	The foo(g(_)) is something you'd actually use in scala, too.
00:48:18	<dolio>	because often times foo(g) would be illegal.
00:48:31	<dolio>	So you're stuck with foo(g(_)) or foo(g _)
00:49:12	<dolio>	Anyhow it means: a => h(a).map(foo(b => g(b))(x))
00:49:52	<dolio>	Or if you kept it as: map(foo(g(_))(x))(h(_)), it'd be: map(foo(a => g(a))(x)(b => h(b)), I believe.
00:49:53	<rwbarton>	is that a => (h(a).map(foo(b => g(b))(x))) ?
00:50:18	<dolio>	Yes. x => e is a lambda expression in Scala.

00:48:52

<quintessence>

I think avoiding the names is the win and avoiding the lambda is the problem

00:50:30	<nand`>	\ -> (or more generally, replacing any distinct instance of _ in the right hand side of a lambda by a new identifier which would be appended to the left hand side of the nearest lambda) might work to save you a few keystrokes;
00:50:37	<nand`>	but then you run into situations such as nesting those
00:52:49	<nand`>	(\a -> f _ 42 _ a) could be assumed equivalent to (\a b c -> f b 42 c a)