Pattern syntax and unary minus

[Maria Mercedes Gutierrez de Guzman <guzman-maria@edu.yale.cs>]

Original-Via: uk.ac.nsf; Sat, 9 Mar 91 09:24:54 GMT
Date: Fri, 8 Mar 91 11:56:03 EST
From: Maria Mercedes Gutierrez de Guzman <guzman-maria@edu.yale.cs>
To: haskell@edu.yale.cs
Subject: Pattern syntax and unary minus
Sender: haskell-request@cs.glasgow.ac.uk

Recent discussion has brought up some unwanted features in pattern
syntax and unary minus behaviour.  Consider the following proposal an
official one.

Pattern syntax and left hand sides will now look like:

pat -> apat
     | con apat1 ... apatk
     | pat1 conop pat2
     | var + integer
     | - integer
     | - float

apat ->  var [@ apat]
       | con
       | integer | float | char | string
       | _
       | ()
       | ( pat )
       | ( pat1 , ... , patk )				(k>=2)
       | [ pat1 , ... , patk ]				
       | ~ apat

lhs -> lhspat
     | var apat1 ... apatk             			(k>=1)
     | - apat
     | pat1 varop pat2
     | ( - apat1 ) apat2 ... apatk			(k>=2)
     | ( pat1 varop pat2 ) apat3 ... apatk		(k>=3)

lhspat -> alhspat
        | con apat1 ... apatk				(k>=1)
        | pat1 conop pat2

alhspat ->  var [@ apat]
          | ( lhspat )
          | ( pat1 , ... , patk )			(k>=2)
          | [ pat1 , ... , patk ]			(k>=1)


There seems to be a concensus towards giving unary minus the same
priority as binary minus.  Therefore,

exp	->  aexp				
	|   exp aexp				function application
	|   exp1 op exp2			operator application
	|   - exp				*** unary - ***
        |   \ apat1 ... apatn [gd] -> exp       lambda abstraction, (n>=1)
	|   if exp1 then exp2 else exp3         conditional
	|   exp where { decls }                 where expression
	|   case exp of { alts }                case expression
        |   exp :: [context =>] atype           expression type signature

Thanks for your comments and specially to Kent Karlsson for bringing
these issues up.

Maria M. Guzman