Yeah. I wanted to propose that as well, but I don't really know how well that scales to larger patterns. On Nov 5, 2009, at 4:42 PM, Sjoerd Visscher wrote:

Let's add point free pattern matching too then:

...

...

myFunc = anotherFunc $ case of Left -> print Right -> putStrLn

Sjoerd

On Nov 5, 2009, at 4:09 PM, Sebastiaan Visser wrote:

...

Hello all,

Wouldn't it be nice if we could write point free case statements?

I regularly find myself writing down something like this:

...

myFunc = anotherFunc $ \x -> case x of Left err -> print err Right msg -> putStrLn msg

We could really use a case statement in which we skip the scrutinee and make `(case of {})' be syntactic sugar for `(\x -> case x of {})'.

So we could write:

...

myFunc = anotherFunc $ case of Left err -> print err Right msg -> putStrLn msg

A minor syntactical addition, a big win!

Cheers,

-- Sebastiaan Visser

Me too. Looks cool! 2009/11/5 Martijn van Steenbergen :

Sebastiaan Visser wrote:

...

 > myFunc = anotherFunc $ case of  >                          Left err -> print err  >                          Right msg -> putStrLn msg

A minor syntactical addition, a big win!

+1!

Martijn. _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

-- Eugene Kirpichov Web IR developer, market.yandex.ru

+1

If we're counting increments, should add in previous instances of the same proposal - Andrew Pimlott Sep 2005 on haskell-cafe, at least. I agree with Stefan Monnier, might as well allow pattern alternatives in lambda expressions - essentially the same idea and allows multiple case parameters. Donn Cave, donn@avvanta.com

How about \{Left err -> print err; Right msg -> putStrLn msg} ? 2009/11/5 Stefan Monnier :

...

We could really use a case statement in which we skip the scrutinee and make (case of {})' be syntactic sugar for `(\x -> case x of {})'.

...

So we could write:

...

...

myFunc = anotherFunc $ case of Left err -> print err Right msg -> putStrLn msg

...

A minor syntactical addition, a big win!

Since this "case" really defines a function, it seems like it would make more sense to allow defining anonymous functions by pattern matching. I.e. instead of "case of", I think it should use "λ", "\", "fn", or ...

       Stefan

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

-- Eugene Kirpichov Web IR developer, market.yandex.ru

On Thu, Nov 5, 2009 at 10:59 AM, Stefan Monnier wrote:

...

We could really use a case statement in which we skip the scrutinee and make (case of {})' be syntactic sugar for `(\x -> case x of {})'.

...

So we could write:

...

...

myFunc = anotherFunc $ case of Left err -> print err Right msg -> putStrLn msg

...

A minor syntactical addition, a big win!

Since this "case" really defines a function, it seems like it would make more sense to allow defining anonymous functions by pattern matching. I.e. instead of "case of", I think it should use "λ", "\", "fn", or ...

The problem with all of those options is that they introduce a new keyword into the language and can potentially break existing code. Eugene's \{ } avoids that by using a different hole in the grammar, but at the expense of 'un-Haskelly' braces. That and I question how easy it would be to get to parse, because a common idiom seems to be to parse patterns as expressions before converting them to patterns to avoid certain other ambiguities in the grammar, so this requires a { } expression, which may introduce a lot more ambiguity and problems to the grammar than it would seem at first glance. -Edward Kmett

2009/11/5 Edward Kmett :

On Thu, Nov 5, 2009 at 10:59 AM, Stefan Monnier wrote:

...

...

We could really use a case statement in which we skip the scrutinee and make (case of {})' be syntactic sugar for `(\x -> case x of {})'.

...

So we could write:

...

...

myFunc = anotherFunc $ case of Left err -> print err Right msg -> putStrLn msg

...

A minor syntactical addition, a big win!

Since this "case" really defines a function, it seems like it would make more sense to allow defining anonymous functions by pattern matching. I.e. instead of "case of", I think it should use "λ", "\", "fn", or ...

The problem with all of those options is that they introduce a new keyword into the language and can potentially break existing code.

Eugene's \{ } avoids that by using a different hole in the grammar, but at the expense of 'un-Haskelly' braces. That and I question how easy it would be to get to parse, because a common idiom seems to be to parse patterns as expressions before converting them to patterns to avoid certain other ambiguities in the grammar, so this requires a { } expression, which may introduce a lot more ambiguity and problems to the grammar than it would seem at first glance.

Hey, the braces are not that un-Haskelly. After all, you already can write "case x of {Left err -> ...; Right res -> ...}" - that's exactly why I suggested this notation. So, I am just suggesting to replace "case of" with "\" and that's all.

-Edward Kmett

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

-- Eugene Kirpichov Web IR developer, market.yandex.ru

On Nov 5, 2009, at 6:26 PM, Jonathan Daugherty wrote:

...

So we could write:

...

myFunc = anotherFunc $ case of Left err -> print err Right msg -> putStrLn msg

A minor syntactical addition, a big win!

+1.

While we're on the topic, what do people think of a related problem, case expressions over monadic values? I run into this often enough that it's a pain. I'd like to take

result <- act1 case result of ... -> actN

and drop the bind entirely to get

case act1 of ... -> actN

I know that there are many helper functions and constructs to make this sort of thing more readable, but sometimes a case expression is a good fit and the preceding bind just ends up being noisy.

-- Jonathan Daugherty

I think your example is ambiguous in the sense that the case cannot know whether it should pattern match on the entire `m a' or just on the value `a' pulled out of the monad . Or maybe I don't entirely understand your example. With the proposed `case of' it would become something like this: act1 >>= case of ... -> actN Cheers, Sebastiaan