ba82ce914563efd4aa546f827afdca7237b0f3ac
[haskell-report.git] / report / syntax-iso.verb
1 %
2 % $Header: /home/cvs/root/haskell-report/report/syntax-iso.verb,v 1.12 2003/01/13 13:08:56 simonpj Exp $
3 %
4 %**<title>Haskell 98 Syntax</title>
5 %**~header
6 \section{Syntax Reference}
7 \label{syntax}
8 \index{syntax}
9
10 \subsection{Notational Conventions}
11
12 These notational conventions are used for presenting syntax:
13
14 \[\ba{cl}
15 "[pattern]"             & \tr{optional} \\
16 "\{pattern\}"           & \tr{zero or more repetitions} \\
17 "(pattern)"             & \tr{grouping} \\
18 "pat_1 | pat_2"         & \tr{choice} \\
19 "pat_{\langle{}pat'\rangle{}}"  & \tr{difference---elements generated by "pat"} \\
20                         & \tr{except those generated by "pat'"} \\
21 "@fibonacci@"           & \tr{terminal syntax in typewriter font}
22 \ea\]
23
24 BNF-like syntax is used throughout, with productions having the form:
25 @@@
26 nonterm         -> alt_1 | alt_2 | ... | alt_n
27 @@@
28
29 In both the lexical and the context-free syntax, there are some
30 ambiguities that are to be resolved by making grammatical phrases as
31 long as possible, proceeding from left to right (in shift-reduce
32 parsing, resolving shift/reduce conflicts by shifting).  In the lexical
33 syntax, this is the ``maximal munch'' rule\index{maximal munch rule}.  In the
34 context-free syntax, this means that conditionals, let-expressions, and
35 lambda abstractions extend to the right as far as possible.
36
37 % here we input a list of the main changes in version 1.1
38 % \input{syntax-changes-11}
39
40 %*anchor on
41 \subsection{Lexical Syntax}
42
43 % This covers only part of the lexical syntax.  The rest is directly
44 % included since it is much more scattered.
45
46 \input{syntax-lexical}
47
48 @@@
49 varid   -> (small \{small | large | digit | @'@ \})_{\langle{}reservedid\rangle{}}
50 conid           -> large \{small | large | digit | @'@ \} 
51 reservedid -> @case@ | @class@ | @data@ | @default@ | @deriving@ | @do@ | @else@
52         | \hprime{@foreign@} | @if@ | @import@ | @in@ | @infix@ | @infixl@
53         | @infixr@ | @instance@ | @let@ | @module@ | @newtype@ | @of@
54         | @then@ | @type@ | @where@ | @_@
55
56 varsym          -> ( \hprime{symbol_{\langle{}@:@\rangle} \{symbol\}} )_{\langle{}reservedop | dashes\rangle{}}
57 consym          -> ( \hprime{@:@ \{symbol\}})_{\langle{}reservedop\rangle{}}
58 reservedop      -> @..@ | @:@ | @::@ | @=@ | @\@ | @|@ | @<-@ | @->@ | {\tt @@} | @~@ | @=>@
59
60 varid                   && (\tr{variables})
61 conid                   && (\tr{constructors})
62 tyvar   ->  varid       & (\tr{type variables})
63 tycon   ->  conid       & (\tr{type constructors})
64 tycls   ->  conid       & (\tr{type classes})
65 modid   ->  \hprime{\{conid @.@\}} conid        & (\tr{modules})
66
67 qvarid   -> [ modid @.@ ] varid
68 qconid   -> [ modid @.@ ] conid
69 qtycon   -> [ modid @.@ ] tycon
70 qtycls   -> [ modid @.@ ] tycls
71 qvarsym  -> [ modid @.@ ] varsym
72 qconsym  -> [ modid @.@ ] consym
73
74 decimal         -> digit\{digit\}
75 octal           -> octit\{octit\}
76 hexadecimal     -> hexit\{hexit\}
77
78 integer         -> decimal
79                 |  @0o@ octal | @0O@ octal
80                 |  @0x@ hexadecimal | @0X@ hexadecimal
81 float           -> decimal @.@ decimal [exponent]
82                 |  decimal exponent
83 exponent        -> (@e@ | @E@) [@+@ | @-@] decimal
84
85 char    ->  @'@ (graphic_{\langle{}@'@ | @\@\rangle{}} | space | escape_{\langle{}@\&@\rangle{}}) @'@
86 string  ->  @"@ \{graphic_{\langle{}@"@  | @\@\rangle{}} | space | escape | gap\} @"@
87 escape  ->  @\@ ( charesc | ascii | decimal | @o@ octal | @x@ hexadecimal )
88 charesc -> @a@ | @b@ | @f@ | @n@ | @r@ | @t@ | @v@ | @\@ | @"@ | @'@ | @&@
89 ascii   -> @^@cntrl | @NUL@ | @SOH@ | @STX@ | @ETX@ | @EOT@ | @ENQ@ | @ACK@ 
90        | @BEL@ | @BS@ | @HT@ | @LF@ | @VT@ | @FF@ | @CR@ | @SO@ | @SI@ | @DLE@ 
91        | @DC1@ | @DC2@ | @DC3@ | @DC4@ | @NAK@ | @SYN@ | @ETB@ | @CAN@ 
92        | @EM@ | @SUB@ | @ESC@ | @FS@ | @GS@ | @RS@ | @US@ | @SP@ | @DEL@
93 cntrl   -> ascLarge | @@ | @[@ | @\@ | @]@ | @^@ | @_@
94 gap     ->  @\@ whitechar \{whitechar\} @\@
95 @@@
96 \indexsyn{varid}%
97 \indexsyn{conid}%
98 \indexsyn{reservedid}%
99 \indexsyn{varsym}%
100 \indexsyn{consym}%
101 \indexsyn{symbol}%
102 \indexsyn{reservedop}%
103 \indexsyn{tyvar}%
104 \indexsyn{tycon}%
105 \indexsyn{tycls}%
106 \indexsyn{modid}%
107 \indexsyn{qvarid}%
108 \indexsyn{qconid}%
109 \indexsyn{qtycon}%
110 \indexsyn{qtycls}%
111 \indexsyn{qvarsym}%
112 \indexsyn{qconsym}%
113 \indexsyn{decimal}%
114 \indexsyn{octal}%
115 \indexsyn{hexadecimal}%
116 \indexsyn{char}%
117 \indexsyn{string}%
118 \indexsyn{escape}%
119 \indexsyn{charesc}%
120 \indexsyn{ascii}%
121 \indexsyn{cntrl}%
122 \indexsyn{gap}%
123
124
125 \subsection{Layout}
126 \label{layout}
127 \index{layout}
128
129 Section~\ref{lexemes-layout} gives an informal discussion of the layout
130 rule. This section defines it more precisely.
131
132 The meaning of a Haskell program may depend on its {\em layout}.
133 The effect of layout on its meaning can be completely described by adding
134 braces and semicolons in places determined by the layout.  The meaning of
135 this augmented program is now layout insensitive.
136
137 The effect of layout is specified in this section by describing
138 how to add braces and semicolons to a laid-out program.  The specification
139 takes the form of a function "L" that performs the translation.
140 The input to "L" is:
141 \begin{itemize}
142 \item 
143 A stream of lexemes as specified by the lexical syntax in the Haskell report,
144 with the following additional tokens: 
145 \begin{itemize}
146 \item If a @let@, @where@, @do@, or @of@ keyword is not followed by the lexeme @{@, 
147 the token "\{n\}" is inserted after the keyword, where "n" is the indentation of the 
148 next lexeme if there is one, or "0" if the end of file has been reached.
149 \item If the first lexeme of a module is not @{@ or @module@, 
150 then it is preceded by "\{n\}" where "n" is the indentation of the lexeme. 
151 \item Where the start of a lexeme is preceded only by white space on the
152    same line, this lexeme is preceded by "<n>" where "n"
153    is the indentation of the lexeme, provided that it is not,
154    as a consequence of the first two rules, preceded by "\{n\}".
155    (NB: a string literal may span multiple lines -- Section~\ref{lexemes-char}.  So in the fragment
156 \bprog
157 @
158   f = ("Hello \
159           \Bill", "Jake")
160 @
161 \eprog
162 There is no "<n>" inserted before the "@\Bill@", because it is not the beginning of
163 a complete lexeme; nor before the "@,@", because it is not preceded only by white space.)
164 \end{itemize}
165
166 \item A stack of ``layout contexts'', in which each element is either:
167 \begin{itemize}
168 \item Zero, indicating that the enclosing context is explicit (i.e. the programmer 
169 supplied the opening brace. 
170 If the innermost context is 0, then no layout tokens will be inserted 
171 until either the enclosing context ends or a new context is pushed. 
172 \item A positive integer, which is the indentation column of the enclosing layout context. 
173 \end{itemize}
174 \end{itemize}
175
176 The ``indentation'' of a lexeme is the column number
177 of the first character of that lexeme; the indentation of a line is the
178 indentation of its leftmost lexeme.  To determine the column number,
179 assume a fixed-width font with the following conventions:
180 \begin{itemize}
181 \item The characters "newline", "return", "linefeed", and "formfeed", all start a new line.
182 \item The first column is designated column 1, not 0.
183 \item Tab stops are 8 characters apart.
184 \item A tab character causes the insertion of
185 enough spaces to align the current position with the next tab stop.
186 \end{itemize}
187 For the purposes of the layout rule, Unicode characters in a source program
188 are considered to be of the same, fixed, width as an ASCII character.
189 However, to avoid visual confusion, programmers should avoid writing programs in which 
190 the meaning of implicit layout depends on the width of non-space characters.
191
192 The application
193 \[
194 L~tokens~[]
195 \]
196 delivers a layout-insensitive translation of "tokens", where "tokens"
197 is the result of lexically analysing a module and adding column-number
198 indicators to it as described above.
199 The definition of "L" is as follows, where we use ``":"'' as a stream
200 construction operator, and ``"\emptystr"'' for the empty stream.
201 % \begin{center}
202 % \[\ba{lcll}
203 %      L~ (<n>:ts)~ (m:ms)   & = & @;@ ~:~ (L~ ts~(m:ms))           &\mbox{if}~ m = n \\
204 %                            & = & @}@ ~:~ (L~ (<n>:ts)~ ms)       & \mbox{if}~ n < m \\
205 %                            & = & L~ ts~(m:ms)                   & \mbox{otherwise} \\
206 % \\
207 %      L~ (\{n\}:ts)~ (m:ms)   & = & @{@ ~:~ (L~ ts~(n:m:ms))         & \mbox{if}~n > m~   (Note~ 1)\\
208 %                            & = & @{@ ~:~ @}@ ~:~  (L~ ts~(<n>:m:ms))  & \mbox{otherwise}~   (Note~ 2)\\
209 % \\
210 %      L~ (t:ts)~ (m:ms)       & = & @}@ ~:~ (L~ (t:ts)~ ms)           & \mbox{if}~ m /= 0 ~\mbox{and}~ \mbox{parse-error}(t) \\
211 %                           &&& (Note~ 3) \\
212 % \\
213 %      L~ (@}@:ts)~ (0:ms)     & = & @}@ ~:~ (L~ ts~ms)     &                       (Note~ 4) \\
214 % \\
215 %      L~ (@{@:ts)~ ms         & = & @{@ ~:~ (L~ ts~(0:ms))                   &     (Note~ 5)\\
216 % \\
217 %      L~ (t:ts)~ ms           & = & t ~:~ (L~ ts~ms)\\
218 % \\
219 %      L~ \emptystr~ [0]                   & = & \emptystr\\
220 %      L~ \emptystr~ (m:ms)        & = & @}@ ~:~ L~ \emptystr~ ms          & \mbox{if}~m \neq 0~  (Note~ 6)
221 % \ea\]
222 % \end{center}
223 \begin{center}
224 \[\ba{lcll}
225      L~ (<n>:ts)~ (m:ms)   & = & @;@ ~:~ (L~ ts~(m:ms))           &\mbox{if}~ m = n \\
226                            & = & @}@ ~:~ (L~ (<n>:ts)~ ms)       & \mbox{if}~ n < m \\
227      L~ (<n>:ts)~ms        & = & L~ ts~ms \\
228 \\
229      L~ (\{n\}:ts)~ (m:ms)   & = & @{@ ~:~ (L~ ts~(n:m:ms))      & \mbox{if}~n > m~   (Note~ 1)\\
230      L~ (\{n\}:ts)~ []       & = & @{@ ~:~ (L~ ts~[n])           & \mbox{if}~n > 0~   (Note~ 1)\\
231      L~ (\{n\}:ts)~ ms       & = & @{@ ~:~ @}@ ~:~  (L~ (<n>:ts)~ms) & (Note~ 2)\\
232 \\
233      L~ (@}@:ts)~ (0:ms)     & = & @}@ ~:~ (L~ ts~ms)           & (Note~ 3) \\
234      L~ (@}@:ts)~ ms         & = & \mbox{parse-error}           & (Note~ 3) \\
235      
236 \\
237      L~ (@{@:ts)~ ms         & = & @{@ ~:~ (L~ ts~(0:ms))       &     (Note~ 4)\\
238 \\
239      L~ (t:ts)~ (m:ms)       & = & @}@ ~:~ (L~ (t:ts)~ ms)      & \mbox{if}~ m /= 0 ~\mbox{and}~ \mbox{parse-error}(t) \\
240                                                                     &&& (Note~ 5) \\
241      L~ (t:ts)~ ms           & = & t ~:~ (L~ ts~ms)\\
242 \\
243      L~ \emptystr~ []              & = & \emptystr\\
244      L~ \emptystr~ (m:ms)          & = & @}@ ~:~ L~ \emptystr~ ms          & \mbox{if}~m \neq 0~  (Note~ 6)
245 \ea\]
246 \end{center}
247 \begin{description}
248 \item[Note 1.] A nested context must be further indented 
249 than the enclosing context ("n>m"). If not, "L" fails, and the compiler should indicate a
250 layout error.  An example is:
251 \bprog
252 @
253   f x = let
254            h y = let
255     p z = z
256                  in p
257         in h
258 @
259 \eprog
260 Here, the definition of @p@ is indented less than the indentation of
261 the enclosing context, which is set in this case by the definition of @h@.
262
263 \item[Note 2.] If the first token after a @where@ (say) is not indented more
264 than the enclosing layout context, then the block must be empty, so empty
265 braces are inserted.  The $\{n\}$ token is replaced by $<n>$, to mimic the
266 situation if the empty braces had been explicit.
267
268 \item[Note 3.] By matching against 0 for the current layout context, 
269 we ensure that an explicit close brace can only match an explicit open brace. 
270 A parse error results if an explicit close brace matches an implicit open brace.
271
272 \item[Note 4.] This clause means that all brace pairs are treated as explicit layout 
273 contexts, including labelled construction and update (Section~\ref{field-ops}). 
274 This is a difference between this formulation and Haskell 1.4.
275
276 \item[Note 5.] The side condition "\mbox{parse-error}(t)" is to be interpreted as follows: 
277 if the tokens generated so far by "L" together with the next token "t" 
278 represent an invalid prefix of the Haskell grammar, and the 
279 tokens generated so far by "L" followed by the token ``@}@''
280 represent a valid prefix of the Haskell grammar, then "\mbox{parse-error}(t)" is true. 
281
282 The test $m /= 0$ checks that an implicitly-added closing brace would match
283 an implicit open brace.
284
285 \item[Note 6.] At the end of the input, any pending close-braces are inserted. 
286 It is an error at this point to be within a non-layout context (i.e.~ "m = 0"). 
287 \end{description}
288
289 If none of the rules given above matches, then the algorithm fails. It
290 can fail for instance when the end of the input is reached, and a
291 non-layout context is active, since the close brace is missing. Some
292 error conditions are not detected by the algorithm, although they
293 could be: for example @let }@.
294
295 Note 1 implements the feature that layout processing can be stopped
296 prematurely by a parse error.  For example
297 \bprog
298 @
299         let x = e; y = x in e'
300 @
301 \eprog
302 is valid, because it translates to 
303 \bprog
304 @
305         let { x = e; y = x } in e'
306 @
307 \eprog
308 The close brace is inserted due to the parse error rule above.
309
310 \startnewsection
311 \subsection{Literate comments}
312 \label{literate}
313 \index{literate comments}
314
315 The ``literate comment''
316 convention, first developed by Richard Bird and Philip Wadler for
317 Orwell, and inspired in turn by Donald Knuth's ``literate
318 programming'', is an alternative style for encoding \Haskell{} source
319 code. 
320 The literate style encourages comments by making them the default.  A
321 line in which ``@>@'' is the first character is treated as part of the
322 program; all other lines are comment.
323
324 The program text is recovered
325 by taking only those lines beginning with ``@>@'', 
326 and replacing the leading ``@>@'' with a space.
327 Layout and comments apply
328 exactly as described in Chapter~\ref{syntax} in the resulting text.
329
330 To capture some cases where one omits an ``@>@'' by mistake, it is an
331 error for a program line to appear adjacent to a non-blank comment line,
332 where a line is taken as blank if it consists only of whitespace.
333
334 By convention, the style of comment is indicated by the file
335 extension, with ``@.hs@'' indicating a usual Haskell file and
336 ``@.lhs@'' indicating a literate Haskell file.  Using this style, a
337 simple factorial program would be:
338 \bprog
339 @
340    This literate program prompts the user for a number
341    and prints the factorial of that number:
342
343 > main :: IO ()
344
345 > main = do putStr "Enter a number: "
346 >           l <- readLine
347 >           putStr "n!= "
348 >           print (fact (read l))
349           
350   This is the factorial function.
351
352 > fact :: Integer -> Integer
353 > fact 0 = 1
354 > fact n = n * fact (n-1)
355 @
356 \eprog
357
358
359 An alternative style of literate programming is particularly
360 suitable for use with the LaTeX text processing system.
361 In this convention, only those parts of the literate program that are
362 entirely enclosed between @\begin{code}@$\ldots$@\end{code}@ delimiters are
363 treated as program text; all other lines are comment.  More precisely:
364 \begin{itemize}
365 \item Program code begins on the first line following a line that begins @\begin{code}@.
366 \item Program code ends just before a subsequent line that begins @\end{code}@ (ignoring
367 string literals, of course).
368 \end{itemize}
369 It is not necessary
370 to insert additional blank lines before or after these delimiters, though
371 it may be stylistically desirable.  For example,
372 \bprog
373 @
374 \documentstyle{article}
375
376 \begin{document}
377
378 \section{Introduction}
379
380 This is a trivial program that prints the first 20 factorials.
381
382 \begin{code}
383 main :: IO ()
384 main =  print [ (n, product [1..n]) | n <- [1..20]]
385 \end{code}
386
387 \end{document}
388 @
389 \eprog
390 This style uses the same file extension.  It is not advisable to mix
391 these two styles in the same file.
392
393 \startnewsection
394 \subsection{Context-Free Syntax}
395 \label{bnf}
396 @@@
397 module -> @module@ modid [exports] @where@ body \indexsyn{module}
398        |  body\indexsyn{modid}
399 body   -> @{@ impdecls @;@ topdecls @}@\indexsyn{body}
400         | @{@ impdecls  @}@
401         | @{@ topdecls  @}@
402
403 impdecls     -> impdecl_1 @;@ ... @;@ impdecl_n         &  (n>=1)\indexsyn{impdecls}
404
405 \indexsyn{exports}exports        -> @(@ export_1 @,@ ... @,@ export_n [ @,@ ] @)@ & (n>=0)
406
407 \indexsyn{export}export   -> qvar
408          |  qtycon [@(..)@ | @(@ cname_1 @,@ ... @,@ cname_n @)@] & (n>=0)
409          |  qtycls [@(..)@ | @(@ qvar_1 @,@ ... @,@ qvar_n @)@] & (n>=0)
410          |  @module@ modid
411
412 \indexsyn{impdecl}impdecl   -> @import@ [@qualified@] modid [@as@ modid] [impspec]
413           |     & (\tr{empty declaration})
414
415 \indexsyn{impspec}impspec   -> @(@ import_1 @,@ ... @,@ import_n [ @,@ ] @)@ & (n>=0)
416              |  @hiding@ @(@ import_1 @,@ ... @,@ import_n [ @,@ ] @)@ &  (n>=0)
417
418 \indexsyn{import}import    -> var
419           |  tycon [ @(..)@ | @(@ cname_1 @,@ ... @,@ cname_n @)@] & (n>=0)
420           |  tycls [@(..)@ | @(@ var_1 @,@ ... @,@ var_n @)@] & (n>=0)
421 \indexsyn{cname}cname     -> var | con
422
423 \indexsyn{topdecls}topdecls -> topdecl_1 @;@ ... @;@ topdecl_n  &  (n>=0)
424 \indexsyn{topdecl}topdecl       -> @type@ simpletype @=@ type
425         |  @data@ [context @=>@] simpletype \hprime{[}@=@ constrs\hprime{]} [deriving]
426         |  @newtype@ [context @=>@] simpletype @=@ newconstr [deriving]
427         |  @class@ [scontext @=>@] tycls tyvar [@where@ cdecls]
428         |  @instance@ [scontext @=>@] qtycls inst [@where@ idecls]
429         |  @default@ @(@type_1 @,@ ... @,@ type_n@)@ & (n>=0)
430         |  @foreign@ fdecl
431         |  decl
432
433 \indexsyn{decls}decls   -> @{@ decl_1 @;@ ... @;@ decl_n  @}@           &  (n>=0)
434 \indexsyn{decl}decl     -> gendecl
435         |  (funlhs | \hprime{pat}) rhs
436
437 \indexsyn{cdecls}cdecls -> @{@ cdecl_1 @;@ ... @;@ cdecl_n  @}@         &  (n>=0)
438 \indexsyn{cdecl}cdecl   -> gendecl
439         |  (funlhs | var) rhs
440
441 \indexsyn{idecls}idecls -> @{@ idecl_1 @;@ ... @;@ idecl_n  @}@         &  (n>=0)
442 \indexsyn{idecl}idecl   -> (funlhs | var) rhs
443         |                                               & (\tr{empty})
444
445 \indexsyn{gendecl}gendecl       -> vars @::@ [context @=>@] type        & (\tr{type signature})
446         |  fixity [integer] ops                 & (\tr{fixity declaration})
447         |                                       & (\tr{empty declaration})
448
449 \indexsyn{ops}ops       -> op_1 @,@ ... @,@ op_n                & (n>=1)
450 \indexsyn{vars}vars     -> var_1 @,@ ...@,@ var_n               & (n>=1)
451 \indexsyn{fixity}fixity -> @infixl@ | @infixr@ | @infix@
452
453 \indexsyn{type}type      -> btype [@->@ type]                    & (\tr{function type})
454
455 \indexsyn{btype}btype    ->  [btype] atype                        & (\tr{type application})
456
457 \indexsyn{atype}atype    ->  gtycon
458           |  tyvar
459           |  @(@ type_1 @,@ ... @,@ type_k @)@ & (\tr{tuple type}, k>=2)
460           |  @[@ type @]@                      & (\tr{list type})
461           |  @(@ type @)@                      & (\tr{parenthesized constructor})
462
463 \indexsyn{gtycon}gtycon    -> qtycon
464           |  @()@                              & (\tr{unit type})
465           |  @[]@                              & (\tr{list constructor})
466           |  @(->)@                            & (\tr{function constructor})
467           |  @(,@\{@,@\}@)@                    & (\tr{tupling constructors})
468
469 \indexsyn{context}context -> class
470         |  @(@ class_1 @,@ ... @,@ class_n @)@          &  (n>=0)
471 \indexsyn{class}class   -> qtycls tyvar                 
472         |  qtycls @(@ tyvar atype_1 ...  atype_n @)@ &  (n>=1)
473 \indexsyn{scontext}scontext -> simpleclass
474         |  @(@ simpleclass_1 @,@ ... @,@ simpleclass_n @)@              &  (n>=0)
475 \indexsyn{simpleclass}simpleclass -> qtycls tyvar                       
476
477 \indexsyn{simpletype}simpletype -> tycon tyvar_1 ... tyvar_k &  (k>=0)
478 \indexsyn{constrs}constrs          -> constr_1 @|@ ... @|@ constr_n     &  (n>=1)
479 \indexsyn{constr}constr    -> con [@!@] atype_1 ... [@!@] atype_k       & (\tr{arity} con = k, k>=0)
480            |  (btype | @!@ atype) conop (btype | @!@ atype) & (\tr{infix} conop)
481            |  con @{@ fielddecl_1 @,@ ... @,@ fielddecl_n @}@ &  (n>=0)
482 \indexsyn{newconstr}newconstr  -> con atype
483            |  con @{@ var @::@ type @}@ 
484 \indexsyn{fielddecl}fielddecl  -> vars @::@ (type | @!@ atype)
485 \indexsyn{deriving}deriving   -> @deriving@ (dclass | @(@dclass_1@,@ ... @,@ dclass_n@)@)&  (n>=0)
486 \indexsyn{dclass}dclass     -> qtycls
487
488 \indexsyn{inst}inst     -> gtycon
489         |  @(@ gtycon tyvar_1 ... tyvar_k @)@   & (k>=0, tyvars \tr{distinct})
490         |  @(@ tyvar_1 @,@ ... @,@ tyvar_k @)@  & (k>=2, tyvars \tr{distinct})
491         |  @[@ tyvar @]@
492         |  @(@ tyvar_1 @->@ tyvar_2 @)@         & tyvar_1 \tr{and} tyvar_2 \tr{distinct}
493
494 \indexsyn{fdecl}fdecl    -> @import@ callconv [safety] impent var @::@ ftype & (\tr{define varibale})
495          |  @export@ callconv expent var @::@ ftype & (\tr{expose variable})
496 callconv -> @ccall@ | @stdcall@ | @cplusplus@  & (\tr{calling convention})
497          | @jvm@ | @dotnet@
498          |  \mbox{\bf system-specific calling conventions}
499 \indexsyn{impent}impent   -> [string] & (\tr{see Section~\ref{sec:ccall}})
500 \indexsyn{expent}expent   -> [string] & (\tr{see Section~\ref{sec:ccall}})
501 \indexsyn{safety}safety   -> @unsafe@ | @safe@
502
503 \indexsyn{ftype}ftype -> frtype
504       |  fatype \rightarrow ftype
505 \indexsyn{frtype}frtype -> fatype
506        | @()@
507 \indexsyn{fatype}fatype -> qtycon atype_1 \ldots atype_k & (k \geq 0)
508
509 \indexsyn{funlhs}funlhs ->  var apat \{ apat \}
510         |   \hprime{pat varop pat}
511         |   @(@ funlhs @)@  apat \{ apat \}
512
513 \indexsyn{rhs}rhs       ->  @=@ exp [@where@ decls]
514         |   gdrhs [@where@ decls]
515
516 \indexsyn{gdrhs}gdrhs   ->  \hprime{guards @=@ exp [gdrhs]}
517
518 \indexsyn{guards}\hprime{guards}        ->  \hprime{@|@ guard_1, ..., guard_n}             & \hprime{(n>=1)}
519 \indexsyn{guard}\hprime{guard}  -> \hprime{pat @<-@ infixexp}   & (\hprime{\tr{pattern guard}})
520          | \hprime{@let@ decls}         & (\hprime{\tr{local declaration}})
521          | infixexp             & (\tr{boolean guard})
522
523 \indexsyn{exp}exp     ->  \hprime{infixexp @::@ [context @=>@] type}   & (\tr{expression type signature})
524         |   \hprime{infixexp}
525
526 \indexsyn{infixexp}\hprime{infixexp} -> \hprime{lexp qop infixexp} & (\tr{infix operator application})
527             | \hprime{@-@ infixexp}             & (\tr{prefix negation})
528             | \hprime{lexp}
529
530 \indexsyn{lexp}\hprime{lexp}    ->  @\@ apat_1 ... apat_n @->@ exp      & (\tr{lambda abstraction}, n>=1)
531         |   @let@ decls @in@ exp                & ({\tr{let expression}})
532         |   @if@ exp \hprime{[@;@]} @then@ exp \hprime{[@;@]} @else@ exp        & (\tr{conditional})
533         |   @case@ exp @of@ @{@ alts @}@        & (\tr{case expression})
534         |   @do@ @{@ stmts  @}@            & (\tr{do expression})
535         |   fexp
536 \indexsyn{fexp}fexp     ->  [fexp] aexp                         & (\tr{function application})
537
538 \indexsyn{aexp}aexp     ->  qvar                                & (\tr{variable})
539         |   gcon                                & (\tr{general constructor})
540         |   literal                             
541         |   @(@ exp @)@                       & (\tr{parenthesized expression})
542         |   @(@ exp_1 @,@ ... @,@ exp_k @)@     & (\tr{tuple}, k>=2)
543         |   @[@ exp_1 @,@ ... @,@ exp_k @]@     & (\tr{list}, k>=1)
544         |   @[@ exp_1 [@,@ exp_2] @..@ [exp_3] @]@ & (\tr{arithmetic sequence})
545         |   @[@ exp @|@ qual_1 @,@ ... @,@ qual_n @]@   & (\tr{list comprehension}, n>=1)
546         |   @(@ \hprime{infixexp qop} @)@        & (\tr{left section})
547         |   @(@ \hprime{qop_{\langle@-@\rangle} infixexp} @)@        & (\tr{right section})
548         |   qcon @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled construction}, n>=0)
549         |   aexp_{\langle{}qcon\rangle{}} @{@ fbind_1 @,@ ... @,@ fbind_n @}@ & (\tr{labeled update}, n >= 1)
550
551 \indexsyn{qual}qual     -> pat @<-@ exp         & (\tr{generator})
552          | @let@ decls          & (\tr{local declaration})
553          | exp                  & (\tr{guard})
554
555 \indexsyn{alts}alts     ->  alt_1 @;@ ... @;@ alt_n             &  (n>=1)
556 \indexsyn{alt}alt       ->  pat @->@ exp [@where@ decls]
557         |   pat gdpat [@where@ decls]
558         |                                       & (empty alternative)
559
560 \indexsyn{gdpat}gdpat   ->  \hprime{guards} @->@ exp [ gdpat ]
561
562 \indexsyn{stmts}stmts -> stmt_1 ... stmt_n exp [@;@]  &  (n>=0)
563 \indexsyn{stmt}stmt -> exp @;@
564       | pat @<-@ exp @;@
565       | @let@ decls @;@
566       | @;@                     & (empty statement)
567
568 \indexsyn{fbind}fbind   ->  qvar @=@ exp
569         
570 \indexsyn{pat}pat     -> \hprime{lpat qconop pat} & (\tr{infix constructor})
571         | \hprime{lpat}
572
573 \indexsyn{lpat}\hprime{lpat} ->  apat
574         | \hprime{@-@ (integer | float)} & (\tr{negative literal})
575         |   gcon apat_1 ... apat_k              & (\tr{arity} gcon = k, k>=1)
576
577 \indexsyn{apat}apat     ->  var [{\tt @@} apat]                 & (\tr{as pattern})
578         |   gcon                                & (\tr{arity} gcon = 0) 
579         |   qcon @{@ fpat_1 @,@ ... @,@ fpat_k @}@ & (\tr{labeled pattern}, k>=0)
580         |   literal
581         |   @_@                                 & (\tr{wildcard})
582         |   @(@ pat @)@                         & (\tr{parenthesized pattern})
583         |   @(@ pat_1 @,@ ... @,@ pat_k @)@     & (\tr{tuple pattern}, k>=2)
584         |   @[@ pat_1 @,@ ... @,@ pat_k @]@     & (\tr{list pattern}, k>=1) 
585         |   @~@ apat                            & (\tr{irrefutable pattern})
586
587 \indexsyn{fpat}fpat    ->  qvar @=@ pat
588
589 \indexsyn{gcon}gcon    ->  @()@
590         |   @[]@
591         |   @(,@\{@,@\}@)@
592         |   qcon
593
594 \indexsyn{var}var       ->  varid | @(@ varsym @)@              & (\tr{variable})
595 \indexsyn{qvar}qvar     ->  qvarid | @(@ qvarsym @)@            & (\tr{qualified variable})
596 \indexsyn{con}con       ->  conid | @(@ consym @)@              & (\tr{constructor})
597 \indexsyn{qcon}qcon     ->  qconid | @(@ gconsym @)@            & (\tr{qualified constructor})
598 \indexsyn{varop}varop   ->  varsym | \bkqB varid \bkqA          & (\tr{variable operator})
599 \indexsyn{qvarop}qvarop ->  qvarsym | \bkqB qvarid \bkqA        & (\tr{qualified variable operator})
600 \indexsyn{conop}conop   ->  consym | \bkqB conid \bkqA          & (\tr{constructor operator})
601 \indexsyn{qconop}qconop ->  gconsym | \bkqB qconid \bkqA        & (\tr{qualified constructor operator})
602 \indexsyn{op}op ->  varop | conop                       & (\tr{operator})
603 \indexsyn{qop}qop     ->  qvarop | qconop                       & (\tr{qualified operator})
604 \indexsyn{gconsym}gconsym ->  @:@ | qconsym
605 @@@
606
607 %*anchor off
608 % Local Variables: 
609 % mode: latex
610 % End:
611 %**~footer
612