Pattern guards in anonymous functions

In the course of a project, I had an idea that would allow less cumbersome use of cases in anonymous functions. Here's a simple example of what I'm proposing:

(\x y | x > y -> x
      | otherwise -> something else)

Currently, the only way to accomplish this is with if() then ... else syntax or the use of the MultiWayIf and LambdaCase extensions. The syntax I've proposed here matches with existing anonymous function syntax and doesn't conflict with any other GHC syntax. This would greatly improve the readability of complex anonymous functions.

Trac metadata

Trac field	Value
Version	7.6.3
Type	FeatureRequest
TypeOfFailure	OtherFailure
Priority	normal
Resolution	Unresolved
Component	Compiler
Test case
Differential revisions
BlockedBy
Related
Blocking
CC
Operating system
Architecture

changed weight to 5

added Tfeature request Trac import labels

One tricky case would be trying to write something like

f z
  | odd z = \x y | x > y -> x
                 | otherwise -> y
  | even z = \x y -> 0

The | even z guard has to be attached to f because it is followed by =, but that requires some look-ahead.

MultiWayIf uses layout to fix this ambiguity, essentially requiring all the | to line up. I find this a bit annoying (but don't have a better idea), because I want to say

if |  blah
   -> blah
   |  blah
   -> blah

which is disallowed. Instead, I need to indent the arrows.

In any case, the layout approach should work for lambdas, I think.

As pointed out in #10807 (closed), you can use curly braces:

{-# LANGUAGE MultiWayIf #-}

x = if { |  True
         -> 1
         |  False
         -> 2 }

MultiWayIf was changed to use layout in #7783 (closed).

Trac metadata

Trac field	Value
Related	- → #7783 (closed), #10807 (closed)

I'm not very familiar with the implementation of MultiWayIf, but having if introduce layout seems more palatable than having an arbitrary "last variable of lambda" do so...

Wouldn't it be the | that introduces the layout?

added Pnormal label