reworking the informal explanation of pattern gaurds
[haskell-report.git] / report / exps.verb
1 %
2 % $Header: /home/cvs/root/haskell-report/report/exps.verb,v 1.20 2003/01/13 13:08:55 simonpj Exp $
3 %
4 %*section 3
5 %**<title>The Haskell 98 Report: Expressions</title>
6 %**~header
7 \section{Expressions}\index{expression}
8 \label{expressions}
9
10 In this chapter, we describe the syntax and informal semantics of
11 \Haskell{} {\em expressions}, including their translations into the
12 \Haskell{} kernel, where appropriate.  Except in the case of @let@
13 expressions, these translations preserve both the static and dynamic
14 semantics.  Free variables and constructors used in these translations
15 always refer to entities defined by the @Prelude@.  For example,
16 ``@concatMap@'' used in the translation of list comprehensions
17 (Section~\ref{list-comprehensions}) means the @concatMap@ defined by
18 the @Prelude@, regardless of whether or not the identifier ``@concatMap@'' is in
19 scope where the list comprehension is used, and (if it is in scope)
20 what it is bound to.
21
22 In the syntax that follows, there are some families of nonterminals
23 indexed by precedence levels (written as a superscript).  Similarly, the
24 nonterminals "op", "varop", and "conop" may have a double index:
25 a letter "l", "r", or "n" for left-, right- or non-associativity and
26 a precedence level.  A precedence-level variable "i" ranges from 0 to 9;
27 an associativity variable "a" varies over "\{l, r, n\}".
28 For example
29 @@@
30 aexp    ->  @(@ exp^{i+1} qop^{(a,i)} @)@
31 @@@
32 actually stands for 30 productions, with 10 substitutions for "i"
33 and 3 for "a".
34
35 @@@
36 exp     ->  exp^0 @::@ [context @=>@] type      & (\tr{expression type signature})
37         |   exp^0
38 exp^i   ->  exp^{i+1} [qop^{({\rm{n}},i)} exp^{i+1}]
39         |   lexp^i
40         |   rexp^i
41 lexp^i  ->  (lexp^i | exp^{i+1}) qop^{({\rm{l}},i)} exp^{i+1}
42 lexp^6  ->  @-@ exp^7
43 rexp^i  ->  exp^{i+1} qop^{({\rm{r}},i)} (rexp^i | exp^{i+1})
44 exp^{10} ->  @\@ apat_1 ... apat_n @->@ exp     & (\tr{lambda abstraction}, n>=1)
45         |   @let@ decls @in@ exp                & ({\tr{let expression}})
46         |   @if@ exp @then@ exp @else@ exp      & (\tr{conditional})
47         |   @case@ exp @of@ @{@ alts  @}@       & (\tr{case expression})
48         |   @do@ @{@ stmts @}@                  & (\tr{do expression})
49         |   fexp
50 fexp    ->  [fexp] aexp                         & (\tr{function application})
51
52 aexp    ->  qvar                                & (\tr{variable})
53         |   gcon                                & (\tr{general constructor})
54         |   literal                             
55         |   @(@ exp @)@                       & (\tr{parenthesized expression})
56         |   @(@ exp_1 @,@ ... @,@ exp_k @)@     & (\tr{tuple}, k>=2)
57         |   @[@ exp_1 @,@ ... @,@ exp_k @]@     & (\tr{list}, k>=1)
58         |   @[@ exp_1 [@,@ exp_2] @..@ [exp_3] @]@ & (\tr{arithmetic sequence})
59         |   @[@ exp @|@ qual_1 @,@ ... @,@ qual_n @]@   & (\tr{list comprehension}, n>=1)
60         |   @(@ exp^{i+1} qop^{(a,i)} @)@        & (\tr{left section})
61         |   @(@ lexp^{i} qop^{(l,i)} @)@        & (\tr{left section})
62         |   @(@ qop^{(a,i)}_{\langle@-@\rangle}  exp^{i+1} @)@        & (\tr{right section})
63         |   @(@ qop^{(r,i)}_{\langle@-@\rangle}  rexp^{i} @)@        & (\tr{right section})
64         |   qcon @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled construction}, n>=0)
65         |   aexp_{\langle{}qcon\rangle{}} @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled update}, n >= 1)
66
67 @@@
68 \indexsyn{exp}%
69 \index{exp@@"exp^i"}%
70 \index{lexp@@"lexp^i"}%
71 \index{rexp@@"rexp^i"}%
72 \indexsyn{aexp}%
73 \indexsyn{fexp}%
74
75 %       Removed Aug 2001: more misleading than helpful. SLPJ
76 % As an aid to understanding this grammar,
77 % Table~\ref{syntax-precedences} shows the relative precedence of
78 % expressions, patterns and definitions, plus an extended associativity.
79 % "-" indicates that the item is non-associative.
80
81 % \begin{table}[tb]
82 % \[
83 % \centerline{
84 % \begin{tabular}{|l|c|}\hline
85 % Item                                          &       Associativity \\ 
86 % \hline
87 %                                               &                       \\
88 % simple terms, parenthesized terms               &     --              \\
89 % irrefutable patterns (@~@)                      &       --            \\
90 % as-patterns ({\tt @@})                          &       right         \\
91 % function application                          &       left            \\
92 % @do@, @if@, @let@, lambda(@\@), @case@ (leftwards)&   right           \\
93 % @case@ (rightwards)                           &       right           \\
94 %                                               &                       \\
95 % infix operators, prec. 9                      &       as defined      \\
96 % \ldots                                                &       \ldots          \\
97 % infix operators, prec. 0                      &       as defined      \\
98 %                                               &                       \\
99 % function types (@->@)                         &       right           \\
100 % contexts (@=>@)                                       &       --              \\
101 % type constraints (@::@)                               &       --              \\
102 % @do@, @if@, @let@, lambda(@\@) (rightwards)   &       right           \\
103 % sequences (@..@)                              &       --              \\
104 % generators (@<-@)                             &       --              \\
105 % grouping (@,@)                                        &       n-ary           \\
106 % guards (@|@)                                  &       --              \\
107 % case alternatives (@->@)                      &       --              \\
108 % definitions (@=@)                             &       --              \\
109 % separation (@;@)                              &       n-ary           \\ 
110 % \hline
111 % \end{tabular}
112 % }
113 % \]
114 % %**<div align=center> <h4>Table 1</h4> </div>
115 % \ecaption{Precedence of expressions, patterns, definitions (highest to lowest)}
116 % \label{syntax-precedences}
117 % \end{table}
118
119 Expressions involving infix operators are disambiguated by the
120 operator's fixity (see Section~\ref{fixity}).  Consecutive
121 unparenthesized operators with the same precedence must both be either
122 left or right associative to avoid a syntax error.
123 Given an unparenthesized expression ``"x qop^{(a,i)} y qop^{(b,j)} z"'', parentheses
124 must be added around either ``"x qop^{(a,i)} y"'' or ``"y qop^{(b,j)}
125 z"'' when "i=j" unless "a=b={\rm l}" or "a=b={\rm r}".
126
127 Negation\index{negation} is the only prefix operator in
128 \Haskell{}; it has the same precedence as the infix @-@ operator
129 defined in the Prelude (see Section~\ref{fixity}, Figure~\ref{prelude-fixities}).
130
131 The grammar is ambiguous regarding the extent of lambda abstractions,
132 let expressions, and conditionals.  The ambiguity is resolved by the
133 meta-rule that each of these constructs extends as far to the right as
134 possible.  
135
136 %       I can't make head or tail of this para, so
137 %       I'm just deleting it.  SLPJ Dec 98
138 % The separation of function arrows from case alternatives solves
139 % the ambiguity that otherwise arises when an unparenthesized
140 % function type is used in an expression, such as the guard in a case
141 % expression.
142
143 Sample parses are shown below.
144 \[\bt{|l|l|}%%b
145 \hline
146 This                                & Parses as                             \\
147 \hline
148 @f x + g y@                         & @(f x) + (g y)@                       \\
149 @- f x + y@                         & @(- (f x)) + y@                       \\
150 @let { ... } in x + y@              & @let { ... } in (x + y)@              \\
151 @z + let { ... } in x + y@          & @z + (let { ... } in (x + y))@        \\
152 @f x y :: Int@                      & @(f x y) :: Int@                      \\
153 @\ x -> a+b :: Int@                 & @\ x -> ((a+b) :: Int@)               \\
154 \hline\et\]
155
156 {\em A note about parsing.}  Expressions that involve the interaction 
157 of fixities with the let/lambda meta-rule
158 may be hard to parse.  For example, the expression
159 \bprog
160 @
161   let x = True in x == x == True
162 @
163 \eprog
164 cannot possibly mean
165 \bprog
166 @
167   let x = True in (x == x == True)
168 @
169 \eprog
170 because @(==)@ is a non-associative operator; so the expression must parse thus:
171 \bprog
172 @
173   (let x = True in (x == x)) == True
174 @
175 \eprog
176 However, implementations may well use a post-parsing pass to deal with fixities,
177 so they may well incorrectly deliver the former parse.  Programmers are advised
178 to avoid constructs whose parsing involves an interaction of (lack of) associativity
179 with the let/lambda meta-rule.
180
181 For the sake of clarity, the rest of this section shows the syntax of
182 expressions without their precedences.
183
184 \subsection{Errors}
185 \label{basic-errors}\index{error}
186 Errors during expression evaluation, denoted by "\bot"\index{"\bot"},
187 are indistinguishable by a Haskell program from non-termination.  Since \Haskell{} is a
188 non-strict language, all \Haskell{} types include "\bot".  That is, a value
189 of any type may be bound to a computation that, when demanded, results
190 in an error.  When evaluated, errors cause immediate program
191 termination and cannot be caught by the user.  The Prelude provides
192 two functions to directly 
193 cause such errors:
194 \bprog
195 @
196 error     :: String -> a
197 undefined :: a
198 @
199 \eprog
200 \indextt{error}
201 \indextt{undefined}
202 A call to @error@ terminates execution of
203 the program and returns an appropriate error indication to the
204 operating system.  It should also display the string in some
205 system-dependent manner.  When @undefined@ is used, the error message
206 is created by the compiler.
207
208 Translations of \Haskell{} expressions use @error@ and @undefined@ to
209 explicitly indicate where execution time errors may occur.  The actual
210 program behavior when an error occurs is up to the implementation.
211 The messages passed to the @error@ function in these translations are
212 only suggestions; implementations may choose to display more or less
213 information when an error occurs.
214
215 \subsection{Variables, Constructors, Operators, and Literals}
216 \label{vars-and-lits}
217 %
218 @@@
219 aexp    ->  qvar                                & (\tr{variable})
220         |   gcon                                & (\tr{general constructor})
221         |   literal                             
222 @@@
223 \indexsyn{var}%
224 \indexsyn{con}%
225 \indexsyn{varop}%
226 \indexsyn{conop}%
227 \indexsyn{op}%
228 @@@
229 gcon    ->  @()@
230         |   @[]@
231         |   @(,@\{@,@\}@)@
232         |   qcon
233
234 var     ->  varid | @(@ varsym @)@              & (\tr{variable})
235 qvar    ->  qvarid | @(@ qvarsym @)@            & (\tr{qualified variable})
236 con     ->  conid | @(@ consym @)@              & (\tr{constructor})
237 qcon    ->  qconid | @(@ gconsym @)@            & (\tr{qualified constructor})
238 varop   ->  varsym | \bkqB varid \bkqA          & (\tr{variable operator})
239 qvarop  ->  qvarsym | \bkqB qvarid \bkqA        & (\tr{qualified variable operator})
240 conop   ->  consym | \bkqB conid \bkqA          & (\tr{constructor operator})
241 qconop  ->  gconsym | \bkqB qconid \bkqA        & (\tr{qualified constructor operator})
242 op      ->  varop | conop                       & (\tr{operator})
243 qop     ->  qvarop | qconop                     & (\tr{qualified operator})
244 gconsym ->  @:@ | qconsym
245 @@@
246 \indexsyn{gcon}%
247 \indexsyn{var}%
248 \indexsyn{qvar}%
249 \indexsyn{con}%
250 \indexsyn{qcon}%
251 \indexsyn{varop}%
252 \indexsyn{qvarop}%
253 \indexsyn{conop}%
254 \indexsyn{qconop}%
255 \indexsyn{qop}%
256 \indexsyn{gconsym}%
257
258 \Haskell{} provides special syntax to support infix notation.
259 An {\em operator} is a function that can be applied using infix 
260 syntax (Section~\ref{operators}), or partially applied using a
261 {\em section} (Section~\ref{sections}).
262
263 An {\em operator} is either an {\em operator symbol}, such as @+@ or @$$@,
264 or is an ordinary identifier enclosed in grave accents (backquotes), such
265 as \bkqB@op@\bkqA.  For example, instead of writing the prefix application
266 @op x y@, one can write the infix application \mbox{@x@ \bkqB@op@\bkqA@ y@}.
267 If no fixity\index{fixity}
268 declaration is given for \bkqB@op@\bkqA{} then it defaults
269 to highest precedence and left associativity
270 (see Section~\ref{fixity}).
271
272 Dually, an operator symbol can be converted to an ordinary identifier
273 by enclosing it in parentheses.  For example, @(+) x y@ is equivalent
274 to @x + y@, and @foldr (*) 1 xs@ is equivalent to @foldr (\x y -> x*y) 1 xs@.
275
276 %       This para is covered by Section 2.4 and 5.5.1
277 % A qualified name may only be used to refer to a variable or
278 % constructor imported from another module (see Section~\ref{import}), or
279 % defined at the top level, 
280 % but not in the definition of a new variable or constructor.  Thus
281 % \bprog
282 % let F.x = 1 in F.x   -- invalid
283 % \eprog
284 % incorrectly uses a qualifier in the definition of @x@, regardless of
285 % the module containing this definition.  Qualification does not affect
286 % the nature of an operator: @F.+@ is an infix operator just as @+@ is.
287
288 Special syntax is used to name some constructors for some of the
289 built-in types, as found
290 in the production for "gcon" and "literal".  These are described
291 in Section~\ref{basic-types}.
292
293 \index{number!translation of literals}
294 An integer literal represents the
295 application of the function @fromInteger@\indextt{fromInteger} to the
296 appropriate value of type 
297 @Integer@.  Similarly, a floating point literal stands for an application of
298 @fromRational@\indextt{fromRational} to a value of type @Rational@ (that is, 
299 @Ratio Integer@).
300
301 \outline{
302 \paragraph*{Translation:}
303 The integer literal "i" is equivalent to @fromInteger@ "i",
304 where @fromInteger@ is a method in class @Num@ (see Section
305 \ref{numeric-literals}).\indexclass{Num}
306
307
308 The floating point literal "f" is equivalent to @fromRational@
309 ("n" @Ratio.%@ "d"), where @fromRational@ is a method in class @Fractional@
310 and @Ratio.%@ constructs a rational from two integers, as defined in
311 the @Ratio@ library.\indexclass{Fractional}
312 The integers "n" and "d" are chosen so that "n/d = f".
313 }
314
315
316 \subsection{Curried Applications and Lambda Abstractions}
317 \label{applications}
318 \label{lambda-abstractions}
319 \index{lambda abstraction}
320 \index{application}
321 %\index{function application|see{application}}
322 %
323 @@@
324 fexp    ->  [fexp] aexp                         & (\tr{function application})
325 exp     ->  @\@ apat_1 ... apat_n @->@ exp      & (\tr{lambda abstraction}, n>=1)
326 @@@
327 \indexsyn{exp}%
328 \indexsyn{fexp}%
329
330 \noindent
331 {\em Function application}\index{application} is written 
332 "e_1 e_2".  Application associates to the left, so the
333 parentheses may be omitted in @(f x) y@.  Because "e_1" could
334 be a data constructor, partial applications of data constructors are
335 allowed. 
336
337 {\em Lambda abstractions} are written 
338 "@\@ p_1 ... p_n @->@ e", where the "p_i" are {\em patterns}.
339 An expression such as @\x:xs->x@ is syntactically incorrect;
340 it may legally be written as @\(x:xs)->x@.
341
342 The set of patterns must be {\em linear}\index{linearity}%
343 \index{linear pattern}---no variable may appear more than once in the set.
344
345 \outline{\small
346 \paragraph*{Translation:}
347 The following identity holds:
348 \begin{center}
349 \bt{lcl}%
350 \struthack{17pt}%
351 "@\@ p_1 ... p_n @->@ e"
352          & "=" &
353         "@\@ x_1 ... x_n @-> case (@x_1@,@ ...@,@ x_n@) of (@p_1@,@ ...@,@ p_n@) ->@ e"
354 \et
355 \end{center}
356 where the "x_i" are new identifiers.
357 }
358 Given this translation combined with the semantics of case
359 expressions and pattern matching described in
360 Section~\ref{case-semantics}, if the
361 pattern fails to match, then the result is "\bot".
362
363              
364 \subsection{Operator Applications}
365 \index{operator application}
366 %\index{operator application|hseealso{application}}
367 \label{operators}
368 %
369 @@@
370 exp     ->  exp_1 qop exp_2
371         |   @-@ exp                             & (\tr{prefix negation})
372 qop     ->  qvarop | qconop                     & (\tr{qualified operator})
373 @@@
374 \indexsyn{exp}%
375 \indexsyn{qop}%
376
377 \noindent
378 The form "e_1 qop e_2" is the infix application of binary
379 operator\index{operator} "qop" to expressions "e_1" and "e_2".  
380
381 The special
382 form "@-@e" denotes prefix negation\index{negation}, the only
383 prefix operator in \Haskell{}, and is 
384 syntax for "@negate @(e)".\indextt{negate}  The binary @-@ operator
385 does not necessarily refer 
386 to the definition of @-@ in the Prelude; it may be rebound 
387 by the module system.  However, unary @-@ will always refer to the
388 @negate@ function defined in the Prelude.  There is no link between
389 the local meaning of the @-@ operator and unary negation.
390
391 Prefix negation has the same precedence as the infix operator @-@
392 defined in the Prelude (see
393 Table~\ref{prelude-fixities}%
394 %*ignore
395 , page~\pageref{prelude-fixities}%
396 %*endignore
397 ).  Because @e1-e2@ parses as an
398 infix application of the binary operator @-@, one must write @e1(-e2)@ for
399 the alternative parsing.  Similarly, @(-)@ is syntax for 
400 @(\ x y -> x-y)@, as with any infix operator, and does not denote 
401 @(\ x -> -x)@---one must use @negate@ for that.
402
403 \outline{
404 \paragraph*{Translation:}
405 The following identities hold:
406 \begin{center}
407 \bt{lcl}%
408 \struthack{17pt}%
409 "e_1 op e_2" & "=" & "@(@op@)@ e_1 e_2" \\
410 "@-@e" & "=" & "@negate@ (e)"
411 \et
412 \end{center}
413 }
414
415 \subsection{Sections}
416 \index{section}
417 %\index{section|hseealso{operator application}}
418 \label{sections}
419 %
420 @@@
421 aexp    ->  @(@ exp^{i+1} qop^{(a,i)} @)@        & (\tr{left section})
422         |   @(@ lexp^{i} qop^{(l,i)} @)@        & (\tr{left section})
423         |   @(@ qop^{(a,i)}_{\langle@-@\rangle}  exp^{i+1} @)@        & (\tr{right section})
424         |   @(@ qop^{(r,i)}_{\langle@-@\rangle}  rexp^{i} @)@        & (\tr{right section})
425 @@@
426 \indexsyn{aexp}%
427
428 \noindent
429 {\em Sections} are written as "@(@ op e @)@" or "@(@ e op @)@", where
430 "op" is a binary operator and "e" is an expression.  Sections are a
431 convenient syntax for partial application of binary operators.
432
433 Syntactic precedence rules apply to sections as follows.
434 "@(@op~e@)@" is legal if and only if "@(x@~op~e@)@" parses 
435 in the same way as "@(x@~op~@(@e@))@";
436 and similarly for  "@(@e~op@)@".
437 For example, @(*a+b)@ is syntactically invalid, but @(+a*b)@ and
438 @(*(a+b))@ are valid.  Because @(+)@ is left associative, @(a+b+)@ is syntactically correct,
439 but @(+a+b)@ is not; the latter may legally be written as @(+(a+b))@.
440 As another example, the expression
441 \bprog
442 @
443   (let n = 10 in n +)
444 @
445 \eprog
446 is invalid because, by the let/lambda meta-rule (Section~\ref{expressions}),
447 the expression
448 \bprog
449 @
450   (let n = 10 in n + x)
451 @
452 \eprog
453 parses as
454 \bprog
455 @
456   (let n = 10 in (n + x))
457 @
458 \eprog
459 rather than
460 \bprog
461 @
462   ((let n = 10 in n) + x)
463 @
464 \eprog
465 % This observation makes it easier to implement the let/lambda meta-rule
466 % (Section~\ref{expressions}) because once the operator has been seen it is clear that any
467 % legal parse must include the operator in the body of the @let@.
468
469 Because @-@ is treated specially in the grammar,
470 "@(-@ exp@)@" is not a section, but an application of prefix
471 negation,\index{negation} as
472 described in the preceding section.  However, there is a @subtract@
473 function defined in the Prelude such that
474 "@(subtract@ exp@)@" is equivalent to the disallowed section.
475 The expression "@(+ (-@ exp@))@" can serve the same purpose.
476
477
478 % Changed to allow postfix operators.  That is, in (op x), we no
479 % longer add a \x -> which would require op to be binary instead
480 % of unary.
481
482 \outline{
483 \paragraph*{Translation:}
484 The following identities hold:
485 \begin{center}
486 \bt{lcl}%
487 \struthack{17pt}%
488 "@(@op e@)@" & "=" & "@\@ x @->@ x op e" \\
489 "@(@e op@)@" & "=" & "@\@ x @->@ e op x"
490 \et
491 \end{center}
492 where "op" is a binary operator, "e" is an expression, and "x" is a variable
493 that does not occur free in "e".
494 }
495
496 \subsection{Conditionals}
497 \label{conditionals}\index{conditional expression}
498 %
499 @@@
500 exp     ->  @if@ exp_1 @then@ exp_2 @else@ exp_3
501 @@@
502 \indexsyn{exp}%
503
504 %\indextt{if ... then ... else ...}
505 A {\em conditional expression}
506 \index{conditional expression}
507 has the form 
508 "@if@ e_1 @then@ e_2 @else@ e_3" and returns the value of "e_2" if the
509 value of "e_1" is @True@, "e_3" if "e_1" is @False@, and "\bot"
510 otherwise.
511
512 \outline{
513 \paragraph*{Translation:}
514 The following identity holds:
515 \begin{center}
516 \bt{lcl}%
517 \struthack{17pt}%
518 "@if@ e_1 @then@ e_2 @else@ e_3"  & "=" & "@case@ e_1 @of { True ->@ e_2 @; False ->@ e_3 @}@"
519 \et
520 \end{center}
521 where @True@ and @False@ are the two nullary constructors from the 
522 type @Bool@, as defined in the Prelude.  The type of "e_1" must be @Bool@;
523 "e_2" and "e_3" must have the same type, which is also the type of the
524 entire conditional expression.
525 }
526
527 \subsection{Lists}
528 \label{lists}
529 %
530 @@@
531 exp     ->  exp_1 qop exp_2
532 aexp    ->  @[@ exp_1 @,@ ... @,@ exp_k @]@     & (k>=1)
533         |   gcon
534 gcon    -> @[]@
535         | qcon
536 qcon    -> @(@ gconsym @)@
537 qop     -> qconop
538 qconop  -> gconsym
539 gconsym -> @:@
540 @@@
541 \indexsyn{aexp}%
542
543 {\em Lists}\index{list} are written "@[@e_1@,@ ...@,@ e_k@]@", where
544 "k>=1".  The list constructor is @:@, and the empty list is denoted @[]@.
545 Standard operations on
546 lists are given in the Prelude (see Section~\ref{basic-lists}, and
547 Chapter~\ref{stdprelude} notably Section~\ref{preludelist}).
548
549 \outline{
550 \paragraph*{Translation:}  
551 The following identity holds:
552 \begin{center}
553 \bt{lcl}%
554 \struthack{17pt}%
555 "@[@e_1@,@ ...@,@ e_k@]@"  & "=" & "e_1 @: (@e_2 @: (@ ... @(@e_k @: [])))@"
556 \et
557 \end{center}
558 where @:@ and @[]@ are constructors for lists, as defined in
559 the Prelude (see Section~\ref{basic-lists}).  The types
560 of "e_1" through "e_k" must all be the same (call it "t\/"), and the
561 type of the overall expression is @[@"t"@]@ (see Section~\ref{type-syntax}).
562 }
563 The constructor ``@:@'' is reserved solely for list construction; like
564 @[]@, it is considered part of the language syntax, and cannot be hidden or redefined.
565 It is a right-associative operator, with precedence level 5 (Section~\ref{fixity}).
566
567 \subsection{Tuples}
568 \label{tuples}
569 %
570 @@@
571 aexp    ->  @(@ exp_1 @,@ ... @,@ exp_k @)@     & (k>=2)
572         | qcon
573 qcon -> @(,@\{@,@\}@)@
574
575 @@@
576 \indexsyn{aexp}%
577
578 {\em Tuples}\index{tuple} are written "@(@e_1@,@ ...@,@ e_k@)@", and may be
579 of arbitrary length "k>=2".  The constructor for an "n"-tuple is denoted by
580 @(,@\ldots@,)@, where there are "n-1" commas.  Thus @(a,b,c)@ and
581 @(,,) a b c@ denote the same value.
582 Standard operations on tuples are given
583 in the Prelude (see Section~\ref{basic-tuples} and Chapter~\ref{stdprelude}).
584
585 \outline{
586 \paragraph*{Translation:}  
587 "@(@e_1@,@ ...@,@ e_k@)@" for "k\geq2" is an instance of a "k"-tuple as
588 defined in the Prelude, and requires no translation.  If
589 "t_1" through "t_k" are the types of "e_1" through "e_k",
590 respectively, then the type of the resulting tuple is 
591 "@(@t_1@,@ ...@,@ t_k@)@" (see Section~\ref{type-syntax}).
592 }
593
594 \subsection{Unit Expressions and Parenthesized Expressions}
595 \label{unit-expression}
596 \index{unit expression}
597 %
598 @@@
599 aexp    ->  gcon
600         |   @(@ exp @)@
601 gcon    -> @()@
602 @@@
603 \indexsyn{aexp}%
604
605 \noindent
606 The form "@(@e@)@" is simply a {\em parenthesized expression}, and is
607 equivalent to "e".  The {\em unit expression} @()@ has type
608 @()@\index{trivial type} (see
609 Section~\ref{type-syntax}).  It is the only member of that type apart
610 from $\bot$, and can
611 be thought of as the ``nullary tuple'' (see Section~\ref{basic-trivial}).
612 \nopagebreak[4]
613
614 \outline{
615 \paragraph{Translation:}  
616 "@(@e@)@" is equivalent to "e".
617 }
618
619 \subsection{Arithmetic Sequences}
620 \label{arithmetic-sequences}
621 %
622 @@@
623 aexp    ->  @[@ exp_1 [@,@ exp_2] @..@ [exp_3] @]@      
624 @@@
625 \indexsyn{aexp}%
626
627 \noindent
628
629
630 The {\em arithmetic sequence}\index{arithmetic sequence}
631 "@[@e_1@,@ e_2 @..@ e_3@]@" denotes a list of values of
632 type "t", where each of the "e_i" has type "t", and "t" is an
633 instance of class @Enum@.
634
635 \outline{
636 \paragraph{Translation:}
637 Arithmetic sequences satisfy these identities:
638 \begin{center}
639 \begin{tabular}{lcl}%
640 \struthack{17pt}%
641 @[ @"e_1"@.. ]@         & "=" 
642                         & @enumFrom@ "e_1" \\
643 @[ @"e_1"@,@"e_2"@.. ]@ & "=" 
644                         & @enumFromThen@ "e_1" "e_2" \\
645 @[ @"e_1"@..@"e_3"@ ]@  & "=" 
646                         & @enumFromTo@ "e_1" "e_3" \\
647 @[ @"e_1"@,@"e_2"@..@"e_3"@ ]@ 
648                         & "=" 
649                         & @enumFromThenTo@ "e_1" "e_2" "e_3"
650 \end{tabular}
651 \end{center}
652 where @enumFrom@, @enumFromThen@, @enumFromTo@, and @enumFromThenTo@
653 are class methods in the class @Enum@ as defined in the Prelude
654 (see Figure~\ref{standard-classes}%
655 %*ignore
656 , page~\pageref{standard-classes}%
657 %*endignore
658 ).
659 }
660
661 The semantics of arithmetic sequences therefore depends entirely
662 on the instance declaration for the type "t".  
663 See Section~\ref{enum-class} for more details of which @Prelude@
664 types are in @Enum@ and their semantics.
665
666 \subsection{List Comprehensions}
667 \index{list comprehension}
668 \index{let expression!in list comprehensions}
669 \label{list-comprehensions}
670 %
671 @@@
672 aexp    -> @[@ exp @|@ qual_1 @,@ ... @,@ qual_n @]@    & (\tr{list comprehension}, n>=1)
673 qual    -> pat @<-@ exp         & (\tr{generator})
674          | @let@ decls          & (\tr{local declaration})
675          | exp                  & (\tr{boolean guard})
676 @@@
677 \indexsyn{aexp}
678 \indexsyn{qual}
679
680 \noindent
681 A {\em list comprehension} has the form "@[@ e @|@ q_1@,@ ...@,@ q_n @]@,
682 n>=1," where the "q_i" qualifiers\index{qualifier} are either
683 \begin{itemize}
684 \item {\em generators}\index{generator} of the form "p @<-@ e", where
685 "p" is a
686 pattern (see Section~\ref{pattern-matching}) of type "t" and "e" is an
687 expression of type "@[@t@]@"
688 \item {\em boolean guards},\index{boolean guard} which are arbitrary expressions of
689 type @Bool@
690 \item {\em local bindings} that provide new definitions for use in
691 the generated expression "e" or subsequent boolean guards and generators.
692 \end{itemize}
693
694 Such a list comprehension returns the list of elements
695 produced by evaluating "e" in the successive environments
696 created by the nested, depth-first evaluation of the generators in the
697 qualifier list.  Binding of variables occurs according to the normal
698 pattern matching rules (see Section~\ref{pattern-matching}), and if a
699 match fails then that element of the list is simply skipped over.  Thus:\nopagebreak[4]
700 \bprog
701 @
702 [ x |  xs   <- [ [(1,2),(3,4)], [(5,4),(3,2)] ], 
703       (3,x) <- xs ]
704 @
705 \eprog
706 yields the list @[4,2]@.  If a qualifier is a boolen guard, it must evaluate
707 to @True@ for the previous pattern match to succeed.  
708 As usual, bindings in list comprehensions can shadow those in outer
709 scopes; for example:
710 \[\ba{lll}
711 @[ x | x <- x, x <- x ]@ & = & @[ z | y <- x, z <- y]@ \\
712 \ea\]
713 \outline{
714 \paragraph{Translation:}
715 List comprehensions satisfy these identities, which may be
716 used as a translation into the kernel:
717 \begin{center}
718 \bt{lcl}%
719 \struthack{17pt}%
720 "@[ @ e@ | True ]@" & = & "@[@e@]@" \\
721 "@[ @ e@ | @q@ ]@" & = & "@[@~ e~@|@~q@, True ]@" \\
722 "@[ @ e@ | @b@,@~ Q ~@]@" & = &
723         "@if@~b~@then@~@[ @ e@ | @Q@ ]@~@else []@" \\
724 "@[ @ e@ | @p @<-@ l@,@~ Q@ ]@" & = &
725         "@let ok@~p~@=@~@[ @ e@ | @Q@ ]@" \\
726 &&       @    ok _ = []@ \\
727 &&      "@in concatMap ok@~ l" \\
728 "@[ @ e@ | let@~decls@,@~ Q@ ]@" & = &
729         "@let@~decls~@in@~@[ @ e@ | @Q@ ]@"
730 \et
731 \end{center}
732 where "e" ranges over expressions, "p" over
733 patterns, "l" over list-valued expressions, "b" over
734 boolean expressions, "decls" over declaration lists, 
735 "q" over qualifiers, and "Q" over sequences of qualifiers.  "@ok@" is a fresh variable.
736 The function @concatMap@, and boolean value @True@, are defined in the Prelude.
737 }
738
739 As indicated by the translation of list comprehensions, variables
740 bound by @let@ have fully polymorphic types while those defined by
741 @<-@ are lambda bound and are thus monomorphic (see Section
742 \ref{monomorphism}).
743
744 \subsection{Let Expressions}
745 \index{let expression}
746 \label{let-expressions}
747 %
748 % Including this syntax blurb does REALLY bad things to page breaking
749 % in the 1.[12] report (sigh); ToDo: hope it goes away.
750 @@@
751 exp     ->  @let@ decls @in@ exp
752 @@@
753 \indexsyn{exp}
754 \index{declaration!within a {\tt let} expression}
755
756 \noindent
757 {\em Let expressions} have the general form
758 "@let {@ d_1 @;@ ...  @;@ d_n @} in@ e",
759 and introduce a
760 nested, lexically-scoped, 
761 mutually-recursive list of declarations (@let@ is often called @letrec@ in
762 other languages).  The scope of the declarations is the expression "e"
763 and the right hand side of the declarations.  Declarations are
764 described in Chapter~\ref{declarations}.  Pattern bindings are matched
765 lazily; an implicit @~@ makes these patterns
766 irrefutable.\index{irrefutable pattern}
767 For example, 
768 \bprog
769 @
770 let (x,y) = undefined in @"e"@
771 @
772 \eprog
773 does not cause an execution-time error until @x@ or @y@ is evaluated.
774
775 \outline{\small
776 \paragraph*{Translation:} The dynamic semantics of the expression 
777 "@let {@ d_1 @;@ ...  @;@ d_n @} in@ e_0" are captured by this
778 translation: After removing all type signatures, each
779 declaration "d_i" is translated into an equation of the form 
780 "p_i @=@ e_i", where "p_i" and "e_i" are patterns and expressions
781 respectively, using the translation in
782 Section~\ref{function-bindings}.  Once done, these identities
783 hold, which may be used as a translation into the kernel:
784 \begin{center}
785 \bt{lcl}%
786 \struthack{17pt}%
787 @let {@"p_1"@=@"e_1"@; @ ... @; @"p_n"@=@"e_n"@} in@ "e_0"
788       &=& @let (~@"p_1"@,@ ... @,~@"p_n"@) = (@"e_1"@,@ ... @,@"e_n"@) in@ "e_0" \\
789 @let @"p"@ = @"e_1" @ in @ "e_0"
790         &=& @case @"e_1"@ of ~@"p"@ -> @"e_0"   \\
791         & & {\rm where no variable in "p" appears free in "e_1"} \\
792 @let @"p"@ = @"e_1" @ in @ "e_0"
793       &=& @let @"p"@ = fix ( \ ~@"p"@ -> @"e_1"@) in@ "e_0"
794 \et
795 \end{center}
796 where @fix@ is the least fixpoint operator.  Note the use of the
797 irrefutable patterns "@~@p".  This translation
798 does not preserve the static semantics because the use of @case@
799 precludes a fully polymorphic typing of the bound variables.
800 %\folks{Needs work -- KH}
801 % This same semantics applies to the top-level of
802 %a program that has been translated into a @let@ expression,
803 % as described at the beginning of Section~\ref{modules}.
804 The static semantics of the bindings in a @let@ expression
805 are described in 
806 Section~\ref{pattern-bindings}.
807 }
808
809 \subsection{Case Expressions}
810 \label{case}
811 %
812 @@@
813 exp     ->  @case@ exp @of@ @{@ alts @}@
814 alts    ->  alt_1 @;@ ... @;@ alt_n             & (n>=1)
815 alt     ->  pat @->@ exp [@where@ decls]
816         |   pat gdpat [@where@ decls]
817         |                                       & (empty alternative)
818
819 gdpat   ->  guards @->@ exp [ gdpat ]
820 guards  ->  @|@ guard_1, ..., guard_n             & (n>=1)
821 guard   -> pat @<-@ exp^0       & (\tr{pattern guard})
822          | @let@ decls          & (\tr{local declaration})
823          | exp^0                & (\tr{boolean guard})
824 @@@
825 \indexsyn{exp}%
826 \indexsyn{alts}%
827 \indexsyn{alt}%
828 \indexsyn{gdpat}%
829 \indexsyn{guards}%
830 \indexsyn{guard}%
831
832
833 A {\em case expression}\index{case expression} has the general form
834 \[
835 "@case@ e @of { @p_1 match_1 @;@ ... @;@ p_n  match_n @}@"
836 \]
837 where each "match_i" is of the general form
838 \[\ba{lll}
839  & "@|@ gs_{i1}"   & "@->@ e_{i1}" \\
840  & "..." \\
841  & "@|@ gs_{im_i}" & "@->@ e_{im_i}" \\
842  & \multicolumn{2}{l}{"@where@ decls_i"}
843 \ea\]
844 (Notice that in the syntax rule for "guards", the ``@|@'' is a 
845 terminal symbol, not the syntactic metasymbol for alternation.)
846 Each alternative "p_i match_i" consists of a 
847 pattern\index{pattern} "p_i" and its matches, "match_i".
848 Each match in turn
849 consists of a sequence of pairs of guards\index{guard}
850 "gs_{ij}" and bodies "e_{ij}" (expressions), followed by
851 optional bindings ("decls_i") that scope over all of the guards and
852 expressions of the alternative.
853
854 \index{Pattern Guards}
855 \index{guards}
856 A {\em guard}\index{guard} has one of the following forms:
857 \begin{itemize}
858 \item {\em pattern guards}\index{pattern guard} are of the form "p @<-@ e", where
859 "p" is a 
860 pattern (see Section~\ref{pattern-matching}) of type "t" and "e" is an
861 expression type "t".  They succeed if the expression "e" matches the pattern "p", and introduce the bindings of the pattern to the environment.
862 \item {\em boolean guards}\index{boolean guard} are arbitrary expressions of
863 type @Bool@.  They succeed if the expression evaluates to @True@, and they do not introduce new names to the environment.  A boolean guard, "g", is semantically equivalent to the pattern guard "@True <- @g".
864 \item {\em local bindings} are of the form "@let @decls".  They always succeed, and they introduce the names defined in "decls" to the environment.
865 \end{itemize}
866
867
868 An alternative of the form
869 \[
870 "pat @->@ exp @where@ decls"
871 \]
872 is treated as shorthand for:
873 \[\ba{lll}
874  & "pat @| True@"   & "@->@ exp" \\
875  & \multicolumn{2}{l}{"@where@ decls"}
876 \ea\]
877
878 A case expression must have at least one alternative and each alternative must
879 have at least one body.  Each body must have the same type, and the
880 type of the whole expression is that type.
881
882 A case expression is evaluated by pattern matching the expression "e"
883 against the individual alternatives.  The alternatives are tried
884 sequentially, from top to bottom.  If "e" matches the pattern of an
885 alternative, then the guarded expressions for that alternative are
886 tried sequentially from top to bottom in the environment of the case
887 expression extended first by the bindings created during the matching
888 of the pattern, and then by the "decls_i" in the @where@ clause
889 associated with that alternative.
890
891 For each guarded expression, the comma-separated guards are tried
892 sequentially from left to right.  If all of them succeed, then the
893 corresponding expression is evaluated in the environment extended with
894 the bindings introduced by the guards.  That is, the bindings that are
895 introduced by a guard (either by using a let clause or a pattern
896 guard) are in scope in the following guards and the corresponding
897 expression.  If any of the guards fail, then this guarded expression
898 fails and the next guarded expression is tried.
899
900 If none of the guarded expressions for a given alternative succeed,
901 then matching continues with the next alternative.  If no alternative
902 succeeds, then the result is "\bot".  Pattern matching is described in
903 Section~\ref{pattern-matching}, with the formal semantics of case
904 expressions in Section~\ref{case-semantics}.
905
906 {\em A note about parsing.} The expression
907 \bprog
908 @
909   case x of { (a,_) | let b = not a in b :: Bool -> a }
910 @
911 \eprog
912 is tricky to parse correctly.  It has a single unambiguous parse, namely
913 \bprog
914 @
915   case x of { (a,_) | (let b = not a in b :: Bool) -> a }
916 @
917 \eprog
918 However, the phrase "@Bool -> a@" is syntactically valid as a type, and
919 parsers with limited lookahead may incorrectly commit to this choice, and hence
920 reject the program.  Programmers are advised, therefore, to avoid guards that
921 end with a type signature --- indeed that is why a "guard" contains 
922 an "exp^0" not an "exp".
923
924 \subsection{Do Expressions}
925 \index{do expression}
926 \label{do-expressions}
927 \index{let expression!in do expressions}
928 \index{monad}
929 %
930 @@@
931 exp -> @do@ @{@ stmts @}@             & (\tr{do expression})
932 stmts -> stmt_1 ... stmt_n exp [@;@]  &  (n>=0)
933 stmt -> exp @;@
934       | pat @<-@ exp @;@
935       | @let@ decls @;@
936       | @;@                     & (empty statement)
937 @@@
938 % The semicolons are done differently than for decls
939 %  Reason: to do it the same way would mean:
940 %       stmts -> stmt1 ; ... ; stmtn ; exp [;]
941 % Now, what happens if n=0?  Is there a ';' before the exp or not?
942 % Putting the ';' on the end of the stmt makes that clear.
943 \indexsyn{exp}%
944 \indexsyn{stmt}%
945 \indexsyn{stmts}%
946
947 A {\em do expression} provides a more conventional syntax for monadic programming.
948 It allows an expression such as 
949 \bprog
950 @
951   putStr "x: "    >> 
952   getLine         >>= \l ->
953   return (words l)
954 @
955 \eprog
956 to be written in a more traditional way as:
957 \bprog
958 @
959   do putStr "x: "
960      l <- getLine
961      return (words l)
962 @
963 \eprog
964 \outline{
965 \paragraph*{Translation:} 
966 Do expressions satisfy these identities, which may be
967 used as a translation into the kernel, after eliminating empty "stmts":
968 \begin{center}
969 \bt{lcl}%
970 \struthack{17pt}%
971 @do {@"e"@}@                       &=& "e"\\
972 @do {@"e"@;@"stmts"@}@             &=& "e" @>> do {@"stmts"@}@ \\
973 @do {@"p"@ <- @"e"@; @"stmts"@}@   &=& @let ok @"p"@ = do {@"stmts"@}@\\
974                                    & & @    ok _ = fail "..."@\\
975                                    & & @  in @"e"@ >>= ok@ \\
976 @do {let@ "decls"@; @"stmts"@}@  &=& @let@ "decls" @in do {@"stmts"@}@\\
977 \et
978 \end{center}
979 The ellipsis @"..."@ stands for a compiler-generated error message,
980 passed to @fail@, preferably giving some indication of the location
981 of the pattern-match failure;
982 the functions @>>@, @>>=@, and @fail@ are operations in the class @Monad@,
983 as defined in the Prelude\indexclass{Monad}; and @ok@ is a fresh
984 identifier. 
985 }
986 As indicated by the translation of @do@, variables bound by @let@ have
987 fully polymorphic types while those defined by @<-@ are lambda bound
988 and are thus monomorphic.
989
990 \subsection{Datatypes with Field Labels}
991 \label{field-ops}
992 \index{data declaration@@{\tt data} declaration}
993 \index{label}
994 \index{field label|see{label}}
995 A datatype declaration may optionally define field labels
996 (see Section~\ref{datatype-decls}).
997 These field labels can be used to 
998 construct, select from, and update fields in a manner
999 that is independent of the overall structure of the datatype.
1000
1001 Different datatypes cannot share common field labels in the same scope.
1002 A field label can be used at most once in a constructor.
1003 Within a datatype, however, a field label can be used in more
1004 than one constructor provided the field has the same typing in all
1005 constructors. To illustrate the last point, consider:
1006 \bprog
1007 @
1008   data S = S1 { x :: Int } | S2 { x :: Int }   -- OK
1009   data T = T1 { y :: Int } | T2 { y :: Bool }  -- BAD
1010 @
1011 \eprog
1012 Here @S@ is legal but @T@ is not, because @y@ is given 
1013 inconsistent typings in the latter.
1014
1015 \subsubsection{Field Selection}
1016 @@@
1017 aexp ->     qvar
1018 @@@
1019 \index{field label!selection}
1020
1021 Field labels are used as selector functions.  When used as a variable,
1022 a field label serves as a function that extracts the field from an
1023 object.  Selectors are top level bindings and so they
1024 may be shadowed by local variables but cannot conflict with 
1025 other top level bindings of the same name.  This shadowing only
1026 affects selector functions; in record construction (Section~\ref{record-construction}) 
1027 and update (Section~\ref{record-update}), field labels
1028 cannot be confused with ordinary variables. 
1029
1030 \outline{
1031 \paragraph*{Translation:} 
1032 A field label "f" introduces a selector function defined as:
1033 \begin{center}
1034 \bt{lcl}
1035 \struthack{17pt}%
1036 "f"@ x@ &=&@case x of {@ "C_1 p_{11} \ldots p_{1k}" @ -> @ "e_1" @;@ 
1037  "\ldots" @;@ "C_n p_{n1} \ldots p_{nk}" @ -> @ "e_n" @}@\\
1038 \et
1039 \end{center}
1040 where "C_1 \ldots C_n" are all the constructors of the datatype containing a
1041 field labeled with "f", "p_{ij}" is @y@ when "f" labels the "j"th
1042 component of "C_i" or @_@ otherwise, and "e_i" is @y@ when some field in
1043 "C_i" has a label of "f" or @undefined@ otherwise.
1044 }
1045 \subsubsection{Construction Using Field Labels}
1046 \label{record-construction}
1047 \index{field label!construction}
1048 @@@
1049 aexp ->  qcon @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled construction}, n>=0)
1050 fbind   ->  qvar @=@ exp
1051 @@@
1052 \indexsyn{fbind}%
1053
1054 A constructor with labeled fields may be used to construct a value 
1055 in which the components are specified by name rather than by position.
1056 Unlike the braces used in declaration lists, these are not subject to
1057 layout; the @{@ and @}@ characters must be explicit.  (This is also
1058 true of field updates and field patterns.)
1059 Construction using field labels is subject to the following constraints:
1060 \begin{itemize}
1061 \item Only field labels declared with the specified constructor may be
1062 mentioned. 
1063 \item A field label may not be mentioned more than once.
1064 \item Fields not mentioned are initialized to $\bot$.
1065 \item A compile-time error occurs when any strict fields (fields
1066 whose declared types are prefixed by @!@) are omitted during
1067 construction.  Strict fields are discussed in Section~\ref{strictness-flags}.
1068 \end{itemize}
1069 The expression @F {}@, where @F@ is a data constructor, is legal 
1070 {\em whether or not @F@ was declared with record syntax} (provided @F@ has no strict
1071 fields --- see the third bullet above); 
1072 it denotes "@F@ \bot_1 ... \bot_n", where "n" is the arity of @F@.
1073
1074 \outline{
1075 \paragraph*{Translation:} 
1076 In the binding "f" @=@ "v", the field "f" labels "v".
1077 \begin{center}
1078 \bt{lcl}
1079 \struthack{17pt}%
1080 "C" @{@ "bs" @}@ &=& "C (pick^C_1 bs @undefined@) \ldots (pick^C_k bs @undefined@)"\\
1081 \et
1082 \end{center}
1083 where "k" is the arity of "C".
1084
1085 The auxiliary function "pick^C_i bs d" is defined as follows:
1086 \begin{quote}
1087     If the "i"th component of a constructor "C" has the
1088     field label "f", and if "f=v" appears in the binding list
1089     "bs", then "pick^C_i bs d" is "v".  Otherwise, "pick^C_i bs d" is
1090     the default value "d".
1091 \end{quote}
1092 }
1093
1094 \subsubsection{Updates Using Field Labels}
1095 \label{record-update}
1096 \index{field label!update}
1097 @@@
1098 aexp ->  aexp_{\langle{}qcon\rangle{}} @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled update}, n>=1)
1099 @@@
1100
1101 Values belonging to a datatype with field labels may be
1102 non-destructively updated.  This creates a new value in which the
1103 specified field values replace those in the existing value.  
1104 Updates are restricted in the following ways:
1105 \begin{itemize}
1106 \item All labels must be taken from the same datatype.
1107 \item At least one constructor must define all of the labels
1108 mentioned in the update.
1109 \item No label may be mentioned more than once.
1110 \item An execution error occurs when the value being updated does
1111 not contain all of the specified labels.
1112 \end{itemize}
1113 \outline{
1114 \paragraph*{Translation:} 
1115 Using the prior definition of "pick",
1116 \begin{center}
1117 \bt{lcl}
1118 \struthack{17pt}%
1119 "e" @{@ "bs" @}@ &=& @case@ "e" @of@\\
1120 &&@        @"C_1 v_1 ... v_{k_1}" @->@ "C_1 (pick^{C_1}_1 bs v_1) ... (pick^{C_1}_{k_1} bs v_{k_1})"\\
1121 &&@            @ ... \\
1122 &&@        @"C_j v_1 ... v_{k_j}" @->@ "C_j (pick^{C_j}_1 bs v_1) ... (pick^{C_j}_{k_j} bs v_{k_j})"\\
1123 &&@        _ -> error "Update error"@\\
1124 \et
1125 \end{center}
1126 where "\{C_1,...,C_j\}" is the set of constructors containing all labels
1127 in "bs", and "k_i" is the arity of "C_i".
1128 }
1129 Here are some examples using labeled fields:
1130 \bprog
1131 @
1132 data T    = C1 {f1,f2 :: Int}
1133           | C2 {f1 :: Int,
1134                 f3,f4 :: Char}
1135 @
1136 \eprog
1137 \[\bt{|l|l|}%%b
1138 \hline
1139 Expression                                  & Translation                       \\
1140 \hline
1141 @C1 {f1 = 3}@                       & @C1 3 undefined@          \\
1142 @C2 {f1 = 1, f4 = 'A', f3 = 'B'}@   & @C2 1 'B' 'A'@            \\
1143 @x {f1 = 1}@                 & @case x of C1 _ f2    -> C1 1 f2@ \\
1144                              & @          C2 _ f3 f4 -> C2 1 f3 f4@   \\
1145 \hline\et\]
1146 The field @f1@ is common to both constructors in T.  This
1147 example translates expressions using constructors in field-label
1148 notation into equivalent expressions using the same constructors
1149 without field labels. 
1150 A compile-time error will result if no single constructor
1151 defines the set of field labels used in an update, such as
1152 @x {f2 = 1, f3 = 'x'}@. 
1153
1154 \subsection{Expression Type-Signatures}
1155 \index{expression type-signature}
1156 \label{expression-type-sigs}
1157 %
1158 @@@
1159 exp ->  exp @::@ [context @=>@] type
1160 @@@
1161 \indexsyn{exp}
1162 \indextt{::}
1163
1164 \nopagebreak[4]
1165 {\em Expression type-signatures} have the form "e @::@ t", where "e"
1166 is an expression and "t" is a type (Section~\ref{type-syntax}); they
1167 are used to type an expression explicitly
1168 and may be used to resolve ambiguous typings due to overloading (see
1169 Section~\ref{default-decls}).  The value of the expression is just that of
1170 "exp".  As with normal type signatures (see
1171 Section~\ref{type-signatures}), the declared type may be more specific than 
1172 the principal type derivable from "exp", but it is an error to give
1173 a type that is more general than, or not comparable to, the
1174 principal type.
1175 \outline{
1176 \paragraph*{Translation:} 
1177 \begin{center}
1178 \bt{lcl}
1179 \struthack{17pt}%
1180 "e @::@ t" & = & "@let {@ v @::@ t@; @ v @=@ e @} in @v"
1181 \et
1182 \end{center}
1183 }
1184
1185
1186 \subsection{Pattern Matching}
1187 \index{pattern-matching}
1188 \label{pattern-matching}
1189 \label{patterns}
1190
1191 {\em Patterns} appear in lambda abstractions, function definitions, pattern
1192 bindings, list comprehensions, do expressions, and case expressions.
1193 However, the 
1194 first five of these ultimately translate into case expressions, so
1195 defining the semantics of pattern matching for case expressions is sufficient.
1196 %it suffices to restrict the definition of the semantics of
1197 %pattern-matching to case expressions.
1198
1199 \subsubsection{Patterns}
1200 \label{pattern-definitions}
1201
1202 Patterns\index{pattern} have this syntax:
1203 @@@
1204 pat     ->  var @+@ integer            & (\tr{successor pattern})
1205         |   pat^0
1206 pat^i   ->  pat^{i+1} [qconop^{({\rm{n}},i)} pat^{i+1}]
1207         |   lpat^i
1208         |   rpat^i
1209 lpat^i  ->  (lpat^i | pat^{i+1}) qconop^{({\rm{l}},i)} pat^{i+1}
1210 lpat^6  ->  @-@ (integer | float)               & (\tr{negative literal})
1211 rpat^i  ->  pat^{i+1} qconop^{({\rm{r}},i)} (rpat^i | pat^{i+1})
1212 pat^{10} ->  apat
1213         |   gcon apat_1 ... apat_k              & (\tr{arity} gcon = k, k>=1)
1214
1215 apat    ->  var [{\tt @@} apat]                 & (\tr{as pattern})
1216         |   gcon                                & (\tr{arity} gcon = 0) 
1217         |   qcon @{@ fpat_1 @,@ ... @,@ fpat_k @}@ & (\tr{labeled pattern}, k>=0)
1218         |   literal
1219         |   @_@                                 & (\tr{wildcard})
1220         |   @(@ pat @)@                         & (\tr{parenthesized pattern})
1221         |   @(@ pat_1 @,@ ... @,@ pat_k @)@     & (\tr{tuple pattern}, k>=2)
1222         |   @[@ pat_1 @,@ ... @,@ pat_k @]@     & (\tr{list pattern}, k>=1) 
1223         |   @~@ apat                            & (\tr{irrefutable pattern})
1224
1225 fpat    ->  qvar @=@ pat
1226 @@@
1227 \indexsyn{pat}%
1228 \index{pat@@"pat^i"}%
1229 \index{lpat@@"lpat^i"}%
1230 \index{rpat@@"rpat^i"}%
1231 \indexsyn{apat}%
1232 \indexsyn{fpats}%
1233 \indexsyn{fpat}%
1234
1235 The arity of a constructor must match the number of
1236 sub-patterns associated with it; one cannot match against a
1237 partially-applied constructor.
1238
1239 All patterns must be {\em linear}\index{linearity}
1240 \index{linear pattern}---no variable may appear more than once.  For
1241 example, this definition is illegal:
1242 @
1243   f (x,x) = x   -- ILLEGAL; x used twice in pattern
1244 @
1245
1246 Patterns of the form "var"{\tt @@}"pat" are called {\em as-patterns},
1247 \index{as-pattern ({\tt {\char'100}})}
1248 and allow one to use "var"
1249 as a name for the value being matched by "pat".  For example,\nopagebreak[4]
1250 \bprog
1251 @
1252 case e of { xs@@(x:rest) -> if x==0 then rest else xs }
1253 @
1254 \eprog
1255 is equivalent to:
1256 \bprog
1257 @
1258 let { xs = e } in
1259   case xs of { (x:rest) -> if x==0 then rest else xs }
1260 @
1261 \eprog
1262
1263 Patterns of the form @_@ are {\em
1264 wildcards}\index{wildcard pattern ({\tt {\char'137}})} and are useful when some part of a pattern
1265 is not referenced on the right-hand-side.  It is as if an
1266 identifier not used elsewhere were put in its place.  For example,
1267 \bprog
1268 @
1269 case e of { [x,_,_]  ->  if x==0 then True else False }
1270 @
1271 \eprog
1272 is equivalent to:
1273 \bprog
1274 @
1275 case e of { [x,y,z]  ->  if x==0 then True else False }
1276 @
1277 \eprog
1278 % where @y@ and @z@ are identifiers not used elsewhere.
1279
1280 %old:
1281 %This translation is also 
1282 %assumed prior to the semantics given below.
1283
1284 \subsubsection{Informal Semantics of Pattern Matching}
1285
1286 Patterns are matched against values.  Attempting to match a pattern
1287 can have one of three results: it may {\em fail\/}; it may {\em
1288 succeed}, returning a binding for each variable in the pattern; or it
1289 may {\em diverge} (i.e.~return "\bot").  Pattern matching proceeds
1290 from left to right, and outside to inside, according to the following rules:
1291 \begin{enumerate}
1292 \item Matching the pattern "var" 
1293 against a value "v" always succeeds and binds "var" to "v".
1294
1295 \item
1296 Matching the pattern "@~@apat" against a value "v" always succeeds.
1297 The free variables in "apat" are bound to the appropriate values if matching
1298 "apat" against "v" would otherwise succeed, and to "\bot" if matching
1299 "apat" against "v" fails or diverges.  (Binding does {\em
1300 not} imply evaluation.)
1301
1302 Operationally, this means that no matching is done on a
1303 "@~@apat" pattern until one of the variables in "apat" is used.
1304 At that point the entire pattern is matched against the value, and if
1305 the match fails or diverges, so does the overall computation.
1306
1307 \item
1308 Matching the wildcard pattern @_@ against any value always succeeds,
1309 and no binding is done.
1310
1311 \item
1312 Matching the pattern "con pat" against a value, where "con" is a
1313 constructor defined by @newtype@, depends on the value:
1314 \begin{itemize}
1315 \item If the value is of the form "con v", then "pat" is matched against "v".
1316 \item If the value is "\bot", then "pat" is matched against "\bot".
1317 \end{itemize}
1318 That is, constructors associated with
1319 @newtype@ serve only to change the type of a value.\index{newtype declaration@@{\tt newtype} declaration}
1320
1321 \item
1322 Matching the pattern "con pat_1 \ldots pat_n" against a value, where "con" is a
1323 constructor defined by @data@, depends on the value:
1324 \begin{itemize}
1325 \item If the value is of the form "con v_1 \ldots v_n", 
1326 sub-patterns are matched left-to-right against the components of the data value;
1327 if all matches succeed, the overall match
1328 succeeds; the first to fail or diverge causes the overall match to
1329 fail or diverge, respectively.  
1330
1331 \item If the value is of the form "con' v_1 \ldots v_m", where "con" is a different 
1332 constructor to "con'", the match fails.
1333
1334 \item If the value is "\bot", the match diverges.
1335 \end{itemize}
1336
1337 \item 
1338 Matching against a constructor using labeled fields is the same as
1339 matching ordinary constructor patterns except that the fields are
1340 matched in the order they are named in the field list.  All fields
1341 listed must be declared by the constructor; fields may not be named
1342 more than once.  Fields not named by the pattern are ignored (matched
1343 against @_@).
1344
1345 \item Matching a numeric, character, or string literal pattern "k" against a value "v"
1346 \index{literal pattern}
1347 succeeds if "v ~@==@ ~k", where @==@
1348 is overloaded based on the type of the pattern.  The match diverges if
1349 this test diverges.
1350
1351 The interpretation of numeric literals is exactly as described in Section~\ref{vars-and-lits};
1352 that is, the overloaded function @fromInteger@ or @fromRational@ is 
1353 applied to an @Integer@ or @Rational@ literal (resp)
1354 to convert it to the appropriate type.
1355
1356 \item Matching an "n@+@k" pattern (where "n" is a variable and "k" is a 
1357 positive integer literal) against a value "v" 
1358 \index{n+k pattern@@"n@+@k" pattern}
1359 succeeds if "x ~@>=@ ~k", resulting in the binding 
1360 of "n" to "x~@-@~k",
1361 and fails otherwise.  Again, the functions @>=@ and @-@ are 
1362 overloaded, depending on the type of the pattern.
1363 The match diverges if the comparison diverges.
1364
1365 The interpretation of the literal "k" is the same as in numeric literal
1366 patterns, except that only integer literals are allowed.
1367
1368 \item
1369 Matching an as-pattern "var"{\tt @@}"apat" against a value "v" is
1370 \index{as-pattern ({\tt {\char'100}})}
1371 the result of matching "apat" against "v", augmented with the binding of
1372 "var" to "v".  If the match of "apat" against "v" fails or diverges,
1373 then so does the overall match.
1374 \end{enumerate}
1375
1376 Aside from the obvious static type constraints (for
1377 example, it is a static error to match a character against a
1378 boolean), the following static class constraints hold: 
1379 \begin{itemize}
1380 \item An integer
1381 literal pattern
1382 \index{integer literal pattern}
1383 can only be matched against a value in the class
1384 @Num@.
1385 \item A floating literal pattern
1386 \index{floating literal pattern}
1387 can only be matched against a value
1388 in the class @Fractional@.
1389 \item An "n@+@k" pattern
1390 \index{n+k pattern@@"n@+@k" pattern}
1391 can only be matched
1392 against a value in the class @Integral@.
1393 \end{itemize}
1394
1395 Many people feel that "n@+@k" patterns should not be used.  These
1396 patterns may be removed or changed in future versions of \Haskell{}. 
1397
1398 It is sometimes helpful to distinguish two kinds of
1399 patterns.  Matching an {\em irrefutable pattern}
1400 \index{irrefutable pattern}
1401 is non-strict: the pattern matches even if the value to be matched is "\bot".
1402 Matching a {\em refutable} pattern is strict: if the value to be matched
1403 \index{refutable pattern}
1404 is "\bot" the match diverges.
1405 The irrefutable patterns are as follows:
1406 a variable, a wildcard, "N apat" where "N" is a constructor
1407 defined by @newtype@ and "apat" is irrefutable (see
1408 Section~\ref{datatype-renaming}), 
1409 \index{newtype declaration@@{\tt newtype} declaration} 
1410 "var"{\tt @@}"apat" where "apat" is irrefutable,
1411 or of the form "@~@apat" (whether or not "apat" is irrefutable).
1412 All other patterns are {\em refutable}.
1413
1414 Here are some examples:
1415 \begin{enumerate}
1416 \item If the pattern @['a','b']@ is matched against "@['x',@\bot@]@", then @'a'@
1417 "fails" to match against @'x'@, and the result is a failed match.  But
1418 if @['a','b']@ is matched against "@[@\bot@,'x']@", then attempting to match
1419 @'a'@ against "\bot" causes the match to "diverge".
1420
1421 \item These examples demonstrate refutable vs.~irrefutable
1422 matching:
1423 \bprog
1424 @
1425 (\ ~(x,y) -> 0) @"\bot"@    @"\Rightarrow"@    0
1426 (\  (x,y) -> 0) @"\bot"@    @"\Rightarrow"@    @"\bot"@
1427 @
1428 \eprog
1429 \bprog
1430 @
1431 (\ ~[x] -> 0) []    @"\Rightarrow"@    0
1432 (\ ~[x] -> x) []    @"\Rightarrow"@    @"\bot"@
1433 @
1434 \eprog
1435 \bprog
1436 @
1437 (\ ~[x,~(a,b)] -> x) [(0,1),@"\bot"@]    @"\Rightarrow"@    (0,1)
1438 (\ ~[x, (a,b)] -> x) [(0,1),@"\bot"@]    @"\Rightarrow"@    @"\bot"@
1439 @
1440 \eprog
1441 \bprog
1442 @
1443 (\  (x:xs) -> x:x:xs) @"\bot"@   @"\Rightarrow"@   @"\bot"@
1444 (\ ~(x:xs) -> x:x:xs) @"\bot"@   @"\Rightarrow"@   @"\bot"@:@"\bot"@:@"\bot"@
1445 @
1446 \eprogNoSkip
1447
1448 \item 
1449 Consider the following declarations:
1450 \bprog
1451 @
1452   newtype N = N Bool
1453   data    D = D !Bool
1454 @
1455 \eprog
1456 These examples illustrate the difference in pattern matching
1457 between types defined by @data@ and @newtype@:
1458 \bprog
1459 @
1460 (\  (N True) -> True) @"\bot"@     @"\Rightarrow"@    @"\bot"@
1461 (\  (D True) -> True) @"\bot"@     @"\Rightarrow"@    @"\bot"@
1462 (\ ~(D True) -> True) @"\bot"@     @"\Rightarrow"@    True
1463 @
1464 \eprog
1465 Additional examples may be found in Section~\ref{datatype-renaming}.
1466
1467 \end{enumerate}
1468 \nopagebreak[4]
1469 % \bprog
1470 % @@
1471 % (\ t -> let (x,y) = t in 0) @@"\bot"@@    @@"\Rightarrow"@@    0
1472 % (\ (x,y) -> 0) @@"\bot"@@    @@"\Rightarrow"@@    @@"\bot"@@
1473 % @@
1474 % \eprog
1475 % \bprog
1476 % @@
1477 % (\ l -> let [x] = l in 0) []    @@"\Rightarrow"@@    0
1478 % (\ l -> let [x] = l in x) []    @@"\Rightarrow"@@    @@"\bot"@@
1479 % @@
1480 % \eprog
1481 % \bprog
1482 % @@
1483 % (\ l -> let [x,t] = l; (a,b) = t in x) [(0,1),@@"\bot"@@]    @@"\Rightarrow"@@    (0,1)
1484 % (\ l -> let [x, (a,b)] = l in x) [(0,1),@@"\bot"@@]    @@"\Rightarrow"@@    @@"\bot"@@
1485 % @@
1486 % \eprog
1487 % \bprog
1488 % @@
1489 % (\  (x:xs) -> x:x:xs) @@"\bot"@@   @@"\Rightarrow"@@   @@"\bot"@@
1490 % (\ l -> let (x:xs) = l in x:x:xs) @@"\bot"@@   @@"\Rightarrow"@@   @@"\bot"@@:@@"\bot"@@:@@"\bot"@@
1491 % @@
1492 % \eprogNoSkip
1493 % \end{enumerate}
1494
1495 Top level patterns in case expressions and the set of top level
1496 patterns in function or pattern bindings may have zero or more
1497 associated {\em qualifiers}\index{qualifier}.  See
1498 Section~\ref{qualifiers-in-patterns}.
1499
1500 The guard semantics have an obvious influence on the
1501 strictness characteristics of a function or case expression.  In
1502 particular, an otherwise irrefutable pattern
1503 \index{irrefutable pattern}
1504 may be evaluated because of a guard.  For example, in
1505 \bprog
1506 @
1507 f :: (Int,Int,Int) -> [Int] -> Int
1508 f ~(x,y,z) [a] | (a == y) = 1
1509 @
1510 \eprog
1511 % \bprog
1512 % @@
1513 % f t [a] | a==y = 1 
1514 %           where (x,y,z) = t
1515 % @@
1516 % \eprog
1517 both @a@ and @y@ will be evaluated by @==@ in the guard.
1518
1519
1520 \subsubsection{Formal Semantics of Pattern Matching}
1521 \label{case-semantics}
1522
1523 The semantics of all pattern matching constructs other than @case@
1524 expressions are defined by giving identities that relate those
1525 constructs to @case@ expressions.  The semantics of
1526 @case@ expressions themselves are in turn given as a series of
1527 identities, in Figures~\ref{simple-case-expr-1}--\ref{simple-case-expr-2}. 
1528 Any implementation should behave so that these identities hold; it is 
1529 not expected that it will use them directly, since that 
1530 would generate rather inefficient code.
1531   
1532 \begin{figure}[tb]
1533 \outlinec{\small
1534 \begin{tabular}{@@{}cl}
1535 (a)&@case @$e$@ of { @$alts$@ } @$=$@ (\@$v$@ -> case @$v$@ of { @$alts$@ }) @"e"\\
1536 &{\rm where $v$ is a new variable}\\
1537 (b)&@case @$v$@ of { @$p_1\ \ match_1$@;  @$\ldots{}$@ ; @$p_n\ \ match_n$@ }@\\
1538    &$=$@  case @$v$@ of { @$p_1\ \ match_1$@ ;@\\
1539    &@                _  -> @$\ldots{}$@ case @$v$@ of {@\\
1540    &@                           @$p_n\ \ match_n$\ @;@\\
1541    &@                           _  -> error "No match" }@$\ldots$@}@\\
1542    &@ @{\rm where each $match_i$ has the form:}\\
1543    &@  | @$g_{i,1}$  @ -> @$e_{i,1}$@ ; @$\ldots{}$@ ; | @$g_{i,m_i}$@ -> @$e_{i,m_i}$@ where { @$decls_i$@ }@\\[4pt]
1544 %\\
1545 (c)&@case @$v$@ of { @$p$@ | @$g_1$@ -> @$e_1$@ ; @$\ldots{}$\\
1546    &\hspace*{4pt}@             | @$g_n$@ -> @$e_n$@ where { @$decls$@ }@\\
1547    &\hspace*{2pt}@            _     -> @$e'$@ }@\\
1548    &$=$@ case @$e'$@ of@\\
1549    &   @  {@$y$@ -> @     {\rm (where "y" is a new variable)}\\
1550  &@   case @$v$@ of {@\\
1551    &@         @$p$@ -> let { @$decls$@ } in@\\
1552    &@                if @$g_1$@ then @$e_1$@ @$\ldots{}$@ else if @$g_n$@ then @$e_n$@ else @$y$ \ @;@\\
1553    &@         _ -> @$y$@ }}@\\[4pt]
1554 %\\
1555 (d)&@case @$v$@ of { ~@$p$@ -> @$e$@; _ -> @$e'$@ }@\\
1556 &$=$@ (\@$x_1$ $\ldots$ $x_n$ @->@ $e$ @) (case @$v$@ of { @$p$@->@ 
1557 $x_1$@ })@ $\ldots$ @(case @$v$@ of { @$p$@ -> @$x_n$@})@\\
1558 &{\rm where $x_1, \ldots, x_n$ are all the variables in $p\/$}\\[4pt]
1559 %\\
1560 (e)&@case @$v$@ of { @$x${\tt @@}$p$@ -> @$e$@; _ -> @$e'$@ }@\\
1561 &$=$@  case @$v$@ of { @$p$@ -> ( \ @$x$@ -> @$e$@ ) @$v$@ ; _ -> @$e'$@ }@\\[4pt]
1562 %\\
1563 (f)&@case @$v$@ of { _ -> @$e$@; _ -> @$e'$@ } @$=$@ @$e$\\[4pt]
1564 \end{tabular}
1565 }
1566 %**<div align=center> <h4>Figure 3</h4> </div>
1567 \ecaption{Semantics of Case Expressions, Part 1}
1568 \label{simple-case-expr-1}
1569 \end{figure}
1570
1571 \begin{figure}[tb]
1572 \outlinec{\small
1573 \begin{tabular}{@@{}cl}
1574 (g)&@case @$v$@ of { @$K\ p_1 \ldots p_n$@ -> @$e$@; _ -> @$e'$@ }@\\
1575 &$=$@ case @$v$@ of {@\\
1576 &@     @$K\ x_1 \ldots x_n$@ -> case @$x_1$@ of {@\\
1577 &@                    @$p_1$@ -> @$\ldots$@ case @$x_n$@ of { @$p_n$@ -> @$e$@ ; _ -> @$e'$@ } @$\ldots$\\
1578 &@                    _  -> @$e'$@ }@\\
1579 &@     _ -> @$e'$@ }@\\[2pt]
1580 &{\rm at least one of $p_1, \ldots, p_n$ is not a variable; $x_1, \ldots, x_n$ are new variables}\\[4pt]
1581 %\\
1582 (h)&@case @$v$@ of { @$k$@ -> @$e$@; _ -> @$e'$@ } @$=$@ if (@$v$@==@$k$@) then @$e$@ else @$e'$ \\
1583 &{\rm where $k$ is a numeric, character, or string literal.} \\[4pt]
1584 %\\
1585 (i)&@case @$v$@ of { @$x$@ -> @$e$@; _ -> @$e'$@ } @$=$@ case @$v$@ of { @$x$@ -> @$e$@ }@\\[4pt]
1586 %\\
1587 (j)&@case @$v$@ of { @$x$@ -> @$e$@ } @$=$@ ( \ @$x$@ -> @$e$@ ) @$v$\\[4pt]
1588 %\\
1589 (k)&@case @$N$ $v$@ of { @$N$@ @$p$@ -> @$e$@; _ -> @$e'$@ }@\\
1590 &$=$@ case @$v$@ of { @$p$@ -> @$e$@; _ -> @$e'$@ }@\\
1591 &{\rm where $N$ is a @newtype@ constructor}\\[4pt]
1592 (l)&@case @$\bot$@ of { @$N$@ @$p$@ -> @$e$@; _ -> @$e'$@ } @$=$@ case @$\bot$@ of { @$p$@ -> @$e$@ }@\\
1593 &{\rm where $N$ is a @newtype@ constructor}\\[4pt]
1594 (m)& @case @ $v$ @ of { @ $K$ @ {@ $f_1$ @ = @ $p_1$ @ , @ $f_2$ @ = @
1595 $p_2$ @ , @ $\ldots$ @} -> @ $e$ @; _ -> @ $e'$ @ }@\\
1596 &$=$ @ case @$e'$@ of {@\\
1597 &@   @$y$@ ->@\\
1598 &@    case @ $v$ @ of { @\\
1599 &@     @ $K$ @ { @ $f_1$ @ = @ $p_1$ @ } ->@\\
1600 &@            case @ $v$ @ of {@ $K$ @ {@ $f_2$ @ = @ $p_2$ @ , @
1601 $\ldots$ @ } -> @ $e$ @; _ -> @ $y$ @ };@\\
1602 &@            _ -> @ $y$ @ }}@\\
1603 &{\rm where $f_1$, $f_2$, $\ldots$ are fields of constructor $K$; $y$
1604 is a new variable}\\[4pt]
1605 (n)&@case @ $v$ @ of { @ $K$ @ {@ $f$ @ = @ $p$ @} -> @ $e$ @; _ -> @
1606 $e'$ @ }@ \\
1607 &$=$@ case @ $v$ @ of {@\\
1608 &   @    @ $K$ $p_1\ \ldots \  p_n$ @ -> @ $e$ @; _ -> @ $e'$ @ }@\\
1609 &{\rm where $p_i$ is $p$ if $f$ labels the $i$th component of $K$,
1610 @_@ otherwise}\\
1611 (o)&@case @ $v$ @ of { @ $K$ @ {} -> @ $e$ @; _ -> @
1612 $e'$ @ }@ \\
1613 &$=$@ case @ $v$ @ of {@\\
1614 &   @    @ $K$ @_@ $\ldots$ @_ -> @ $e$ @; _ -> @ $e'$ @ }@\\
1615 (p)&@case (@$K'$@ @$e_1$@ @$\ldots$@ @$e_m$@) of { @$K$@ @$x_1$@ @$\ldots$@ @$x_n$@ -> @$e$@; _ -> @$e'$@ } @$=$@ @$e'$\\
1616 &{\rm where $K$ and $K'$ are distinct @data@ constructors of arity $n$ and $m$, respectively}\\[4pt]
1617 %\\
1618 (q)&@case (@$K$@ @$e_1$@ @$\ldots$@ @$e_n$@) of { @$K$@ @$x_1$@ @$\ldots$@ @$x_n$@ -> @$e$@; _ -> @$e'$@ }@\\
1619 &$=$@ (\@$x_1~\ldots~x_n$@ -> @$e$@) @$e_1~\ldots~e_n$\\
1620 &{\rm where $K$ is a @data@ constructor of arity $n$}\\[4pt]
1621
1622 (r)&@case@~$\bot$~@of { @$K$@ @$x_1$@ @$\ldots$@ @$x_n$@ -> @$e$@; _ -> @$e'$@ }@ ~$=$~ $\bot$ \\
1623 &{\rm where $K$ is a @data@ constructor of arity $n$}\\[4pt]
1624
1625 (s)&@case @$v$@ of { @$x$@+@$k$@ -> @$e$@; _ -> @$e'$@ }@\\
1626 &$=$@ if @$v$@ >= @$k$@ then (\@$x$@ -> @$e$@) (@$v$@-@$k$@) else @$e'$\\
1627 &{\rm where $k$ is a numeric literal}\\
1628 \end{tabular}
1629 }
1630 %**<div align=center> <h4>Figure 4</h4> </div>
1631 \ecaption{Semantics of Case Expressions, Part 2}
1632 \label{simple-case-expr-2}
1633 \end{figure}
1634
1635 In Figures~\ref{simple-case-expr-1}--\ref{simple-case-expr-2}:
1636 "e", "e'" and "e_i" are expressions; 
1637 "g" and "g_i" are boolean-valued expressions; 
1638 "p" and "p_i" are patterns; 
1639 "v", "x", and "x_i" are variables; 
1640 "K" and "K'" are algebraic datatype (@data@) constructors (including
1641 tuple constructors);  and "N" is a @newtype@ constructor\index{newtype declaration@@{\tt newtype} declaration}.
1642 % For clarity, several rules are expressed using
1643 % @let@ (used only in a non-recursive way); their usual purpose is to
1644 % prevent name capture
1645 % (e.g., in rule~(c)).  The rules may be re-expressed entirely with
1646 % @cases@ by applying this identity:
1647 % \[
1648 % "@let @x@ = @y@ in @e@ @ =@  case @y@ of { @x@ -> @e@ }@"
1649 % \]
1650
1651 %Using all but the last two identities (rules~(n) and~(o)) in Figure~\ref{simple-case-expr-2}
1652 %in a left-to-right manner yields a translation into a
1653 %subset of general @case@ expressions called {\em simple case expressions}.%
1654 %\index{simple case expression}
1655 Rule~(b) matches a general source-language
1656 @case@ expression, regardless of whether it actually includes
1657 guards---if no guards are written, then @True@ is substituted for the guards "g_{i,j}"
1658 in the "match_i" forms.
1659 Subsequent identities manipulate the resulting @case@ expression into simpler
1660 and simpler forms.
1661 %The semantics of simple @case@ expressions is 
1662 %given by the last two identities ((n) and~(o)).
1663
1664 Rule~(h) in Figure~\ref{simple-case-expr-2} involves the
1665 overloaded operator @==@; it is this rule that defines the
1666 meaning of pattern matching against overloaded constants.
1667 \index{pattern-matching!overloaded constant}
1668
1669 %% When used as a translation, the identities in
1670 %% Figure~\ref{simple-case-expr} will generate a very inefficient
1671 %% program.  This can be fixed by using further @case@ or @let@ 
1672 %% expressions, but doing so 
1673 %% would clutter the identities, which are intended only to convey the semantics.
1674
1675 These identities all preserve the static semantics.  Rules~(d),~(e), (j), (q), and~(s)
1676 use a lambda rather than a @let@; this indicates that variables bound
1677 by @case@ are monomorphically typed (Section~\ref{type-semantics}).
1678 \index{monomorphic type variable}
1679
1680 %**~footer
1681
1682 % Local Variables: 
1683 % mode: latex
1684 % End: