5 chapter {* Inner syntax --- the term language \label{ch:inner-syntax} *}
7 section {* Printing logical entities *}
9 subsection {* Diagnostic commands *}
12 \begin{matharray}{rcl}
13 @{command_def "typ"}@{text "\<^sup>*"} & : & @{text "context \<rightarrow>"} \\
14 @{command_def "term"}@{text "\<^sup>*"} & : & @{text "context \<rightarrow>"} \\
15 @{command_def "prop"}@{text "\<^sup>*"} & : & @{text "context \<rightarrow>"} \\
16 @{command_def "thm"}@{text "\<^sup>*"} & : & @{text "context \<rightarrow>"} \\
17 @{command_def "prf"}@{text "\<^sup>*"} & : & @{text "context \<rightarrow>"} \\
18 @{command_def "full_prf"}@{text "\<^sup>*"} & : & @{text "context \<rightarrow>"} \\
19 @{command_def "pr"}@{text "\<^sup>*"} & : & @{text "any \<rightarrow>"} \\
22 These diagnostic commands assist interactive development by printing
23 internal logical entities in a human-readable fashion.
34 ( 'prf' | 'full\_prf' ) modes? thmrefs?
36 'pr' modes? nat? (',' nat)?
39 modes: '(' (name + ) ')'
45 \item @{command "typ"}~@{text \<tau>} reads and prints types of the
46 meta-logic according to the current theory or proof context.
48 \item @{command "term"}~@{text t} and @{command "prop"}~@{text \<phi>}
49 read, type-check and print terms or propositions according to the
50 current theory or proof context; the inferred type of @{text t} is
51 output as well. Note that these commands are also useful in
52 inspecting the current environment of term abbreviations.
54 \item @{command "thm"}~@{text "a\<^sub>1 \<dots> a\<^sub>n"} retrieves
55 theorems from the current theory or proof context. Note that any
56 attributes included in the theorem specifications are applied to a
57 temporary context derived from the current theory or proof; the
58 result is discarded, i.e.\ attributes involved in @{text "a\<^sub>1,
59 \<dots>, a\<^sub>n"} do not have any permanent effect.
61 \item @{command "prf"} displays the (compact) proof term of the
62 current proof state (if present), or of the given theorems. Note
63 that this requires proof terms to be switched on for the current
64 object logic (see the ``Proof terms'' section of the Isabelle
65 reference manual for information on how to do this).
67 \item @{command "full_prf"} is like @{command "prf"}, but displays
68 the full proof term, i.e.\ also displays information omitted in the
69 compact proof term, which is denoted by ``@{text _}'' placeholders
72 \item @{command "pr"}~@{text "goals, prems"} prints the current
73 proof state (if present), including the proof context, current facts
74 and goals. The optional limit arguments affect the number of goals
75 and premises to be displayed, which is initially 10 for both.
76 Omitting limit values leaves the current setting unchanged.
80 All of the diagnostic commands above admit a list of @{text modes}
81 to be specified, which is appended to the current print mode (see
82 also \cite{isabelle-ref}). Thus the output behavior may be modified
83 according particular print mode features. For example, @{command
84 "pr"}~@{text "(latex xsymbols)"} would print the current proof state
85 with mathematical symbols and special characters represented in
86 {\LaTeX} source, according to the Isabelle style
89 Note that antiquotations (cf.\ \secref{sec:antiq}) provide a more
90 systematic way to include formal items into the printed text
95 subsection {* Details of printed content *}
99 @{index_ML show_types: "bool Unsynchronized.ref"} & default @{ML false} \\
100 @{index_ML show_sorts: "bool Unsynchronized.ref"} & default @{ML false} \\
101 @{index_ML show_consts: "bool Unsynchronized.ref"} & default @{ML false} \\
102 @{index_ML long_names: "bool Unsynchronized.ref"} & default @{ML false} \\
103 @{index_ML short_names: "bool Unsynchronized.ref"} & default @{ML false} \\
104 @{index_ML unique_names: "bool Unsynchronized.ref"} & default @{ML true} \\
105 @{index_ML show_brackets: "bool Unsynchronized.ref"} & default @{ML false} \\
106 @{index_ML eta_contract: "bool Unsynchronized.ref"} & default @{ML true} \\
107 @{index_ML goals_limit: "int Unsynchronized.ref"} & default @{ML 10} \\
108 @{index_ML Proof.show_main_goal: "bool Unsynchronized.ref"} & default @{ML false} \\
109 @{index_ML show_hyps: "bool Unsynchronized.ref"} & default @{ML false} \\
110 @{index_ML show_tags: "bool Unsynchronized.ref"} & default @{ML false} \\
111 @{index_ML show_question_marks: "bool Unsynchronized.ref"} & default @{ML true} \\
114 These global ML variables control the detail of information that is
115 displayed for types, terms, theorems, goals etc.
117 In interactive sessions, the user interface usually manages these
118 global parameters of the Isabelle process, even with some concept of
119 persistence. Nonetheless it is occasionally useful to manipulate ML
120 variables directly, e.g.\ using @{command "ML_val"} or @{command
123 Batch-mode logic sessions may be configured by putting appropriate
124 ML text directly into the @{verbatim ROOT.ML} file.
128 \item @{ML show_types} and @{ML show_sorts} control printing of type
129 constraints for term variables, and sort constraints for type
130 variables. By default, neither of these are shown in output. If
131 @{ML show_sorts} is set to @{ML true}, types are always shown as
134 Note that displaying types and sorts may explain why a polymorphic
135 inference rule fails to resolve with some goal, or why a rewrite
136 rule does not apply as expected.
138 \item @{ML show_consts} controls printing of types of constants when
139 displaying a goal state.
141 Note that the output can be enormous, because polymorphic constants
142 often occur at several different type instances.
144 \item @{ML long_names}, @{ML short_names}, and @{ML unique_names}
145 control the way of printing fully qualified internal names in
146 external form. See also \secref{sec:antiq} for the document
147 antiquotation options of the same names.
149 \item @{ML show_brackets} controls bracketing in pretty printed
150 output. If set to @{ML true}, all sub-expressions of the pretty
151 printing tree will be parenthesized, even if this produces malformed
152 term syntax! This crude way of showing the internal structure of
153 pretty printed entities may occasionally help to diagnose problems
154 with operator priorities, for example.
156 \item @{ML eta_contract} controls @{text "\<eta>"}-contracted printing of
159 The @{text \<eta>}-contraction law asserts @{prop "(\<lambda>x. f x) \<equiv> f"},
160 provided @{text x} is not free in @{text f}. It asserts
161 \emph{extensionality} of functions: @{prop "f \<equiv> g"} if @{prop "f x \<equiv>
162 g x"} for all @{text x}. Higher-order unification frequently puts
163 terms into a fully @{text \<eta>}-expanded form. For example, if @{text
164 F} has type @{text "(\<tau> \<Rightarrow> \<tau>) \<Rightarrow> \<tau>"} then its expanded form is @{term
165 "\<lambda>h. F (\<lambda>x. h x)"}.
167 Setting @{ML eta_contract} makes Isabelle perform @{text
168 \<eta>}-contractions before printing, so that @{term "\<lambda>h. F (\<lambda>x. h x)"}
169 appears simply as @{text F}.
171 Note that the distinction between a term and its @{text \<eta>}-expanded
172 form occasionally matters. While higher-order resolution and
173 rewriting operate modulo @{text "\<alpha>\<beta>\<eta>"}-conversion, some other tools
174 might look at terms more discretely.
176 \item @{ML goals_limit} controls the maximum number of subgoals to
177 be shown in goal output.
179 \item @{ML Proof.show_main_goal} controls whether the main result to
180 be proven should be displayed. This information might be relevant
181 for schematic goals, to inspect the current claim that has been
184 \item @{ML show_hyps} controls printing of implicit hypotheses of
185 local facts. Normally, only those hypotheses are displayed that are
186 \emph{not} covered by the assumptions of the current context: this
187 situation indicates a fault in some tool being used.
189 By setting @{ML show_hyps} to @{ML true}, output of \emph{all}
190 hypotheses can be enforced, which is occasionally useful for
193 \item @{ML show_tags} controls printing of extra annotations within
194 theorems, such as internal position information, or the case names
195 being attached by the attribute @{attribute case_names}.
197 Note that the @{attribute tagged} and @{attribute untagged}
198 attributes provide low-level access to the collection of tags
199 associated with a theorem.
201 \item @{ML show_question_marks} controls printing of question marks
202 for schematic variables, such as @{text ?x}. Only the leading
203 question mark is affected, the remaining text is unchanged
204 (including proper markup for schematic variables that might be
205 relevant for user interfaces).
211 subsection {* Printing limits *}
215 @{index_ML Pretty.margin_default: "int Unsynchronized.ref"} \\
216 @{index_ML print_depth: "int -> unit"} \\
219 These ML functions set limits for pretty printed text.
223 \item @{ML Pretty.margin_default} indicates the global default for
224 the right margin of the built-in pretty printer, with initial value
225 76. Note that user-interfaces typically control margins
226 automatically when resizing windows, or even bypass the formatting
227 engine of Isabelle/ML altogether and do it within the front end via
230 \item @{ML print_depth}~@{text n} limits the printing depth of the
231 ML toplevel pretty printer; the precise effect depends on the ML
232 compiler and run-time system. Typically @{text n} should be less
233 than 10. Bigger values such as 100--1000 are useful for debugging.
239 section {* Mixfix annotations *}
241 text {* Mixfix annotations specify concrete \emph{inner syntax} of
242 Isabelle types and terms. Locally fixed parameters in toplevel
243 theorem statements, locale specifications etc.\ also admit mixfix
246 \indexouternonterm{infix}\indexouternonterm{mixfix}\indexouternonterm{structmixfix}
248 infix: '(' ('infix' | 'infixl' | 'infixr') string nat ')'
250 mixfix: infix | '(' string prios? nat? ')' | '(' 'binder' string prios? nat ')'
252 structmixfix: mixfix | '(' 'structure' ')'
255 prios: '[' (nat + ',') ']'
259 Here the \railtok{string} specifications refer to the actual mixfix
260 template, which may include literal text, spacing, blocks, and
261 arguments (denoted by ``@{text _}''); the special symbol
262 ``@{verbatim "\<index>"}'' (printed as ``@{text "\<index>"}'') represents an index
263 argument that specifies an implicit structure reference (see also
264 \secref{sec:locale}). Infix and binder declarations provide common
265 abbreviations for particular mixfix declarations. So in practice,
266 mixfix templates mostly degenerate to literal text for concrete
267 syntax, such as ``@{verbatim "++"}'' for an infix symbol.
269 \medskip In full generality, mixfix declarations work as follows.
270 Suppose a constant @{text "c :: \<tau>\<^sub>1 \<Rightarrow> \<dots> \<tau>\<^sub>n \<Rightarrow> \<tau>"} is
271 annotated by @{text "(mixfix [p\<^sub>1, \<dots>, p\<^sub>n] p)"}, where @{text
272 "mixfix"} is a string @{text "d\<^sub>0 _ d\<^sub>1 _ \<dots> _ d\<^sub>n"} consisting of
273 delimiters that surround argument positions as indicated by
276 Altogether this determines a production for a context-free priority
277 grammar, where for each argument @{text "i"} the syntactic category
278 is determined by @{text "\<tau>\<^sub>i"} (with priority @{text "p\<^sub>i"}), and
279 the result category is determined from @{text "\<tau>"} (with
280 priority @{text "p"}). Priority specifications are optional, with
281 default 0 for arguments and 1000 for the result.
283 Since @{text "\<tau>"} may be again a function type, the constant
284 type scheme may have more argument positions than the mixfix
285 pattern. Printing a nested application @{text "c t\<^sub>1 \<dots> t\<^sub>m"} for
286 @{text "m > n"} works by attaching concrete notation only to the
287 innermost part, essentially by printing @{text "(c t\<^sub>1 \<dots> t\<^sub>n) \<dots> t\<^sub>m"}
288 instead. If a term has fewer arguments than specified in the mixfix
289 template, the concrete syntax is ignored.
291 \medskip A mixfix template may also contain additional directives
292 for pretty printing, notably spaces, blocks, and breaks. The
293 general template format is a sequence over any of the following
298 \item @{text "d"} is a delimiter, namely a non-empty sequence of
299 characters other than the following special characters:
303 @{verbatim "'"} & single quote \\
304 @{verbatim "_"} & underscore \\
305 @{text "\<index>"} & index symbol \\
306 @{verbatim "("} & open parenthesis \\
307 @{verbatim ")"} & close parenthesis \\
308 @{verbatim "/"} & slash \\
312 \item @{verbatim "'"} escapes the special meaning of these
313 meta-characters, producing a literal version of the following
314 character, unless that is a blank.
316 A single quote followed by a blank separates delimiters, without
317 affecting printing, but input tokens may have additional white space
320 \item @{verbatim "_"} is an argument position, which stands for a
321 certain syntactic category in the underlying grammar.
323 \item @{text "\<index>"} is an indexed argument position; this is the place
324 where implicit structure arguments can be attached.
326 \item @{text "s"} is a non-empty sequence of spaces for printing.
327 This and the following specifications do not affect parsing at all.
329 \item @{verbatim "("}@{text n} opens a pretty printing block. The
330 optional number specifies how much indentation to add when a line
331 break occurs within the block. If the parenthesis is not followed
332 by digits, the indentation defaults to 0. A block specified via
333 @{verbatim "(00"} is unbreakable.
335 \item @{verbatim ")"} closes a pretty printing block.
337 \item @{verbatim "//"} forces a line break.
339 \item @{verbatim "/"}@{text s} allows a line break. Here @{text s}
340 stands for the string of spaces (zero or more) right after the
341 slash. These spaces are printed if the break is \emph{not} taken.
345 For example, the template @{verbatim "(_ +/ _)"} specifies an infix
346 operator. There are two argument positions; the delimiter
347 @{verbatim "+"} is preceded by a space and followed by a space or
348 line break; the entire phrase is a pretty printing block.
350 The general idea of pretty printing with blocks and breaks is also
351 described in \cite{paulson-ml2}.
355 section {* Explicit notation *}
358 \begin{matharray}{rcll}
359 @{command_def "type_notation"} & : & @{text "local_theory \<rightarrow> local_theory"} \\
360 @{command_def "no_type_notation"} & : & @{text "local_theory \<rightarrow> local_theory"} \\
361 @{command_def "notation"} & : & @{text "local_theory \<rightarrow> local_theory"} \\
362 @{command_def "no_notation"} & : & @{text "local_theory \<rightarrow> local_theory"} \\
363 @{command_def "write"} & : & @{text "proof(state) \<rightarrow> proof(state)"} \\
367 ('type\_notation' | 'no\_type\_notation') target? mode? \\ (nameref mixfix + 'and')
369 ('notation' | 'no\_notation') target? mode? \\ (nameref structmixfix + 'and')
371 'write' mode? (nameref structmixfix + 'and')
377 \item @{command "type_notation"}~@{text "c (mx)"} associates mixfix
378 syntax with an existing type constructor. The arity of the
379 constructor is retrieved from the context.
381 \item @{command "no_type_notation"} is similar to @{command
382 "type_notation"}, but removes the specified syntax annotation from
385 \item @{command "notation"}~@{text "c (mx)"} associates mixfix
386 syntax with an existing constant or fixed variable. The type
387 declaration of the given entity is retrieved from the context.
389 \item @{command "no_notation"} is similar to @{command "notation"},
390 but removes the specified syntax annotation from the present
393 \item @{command "write"} is similar to @{command "notation"}, but
394 works within an Isar proof body.
398 Note that the more primitive commands @{command "syntax"} and
399 @{command "no_syntax"} (\secref{sec:syn-trans}) provide raw access
400 to the syntax tables of a global theory.
404 section {* The Pure syntax \label{sec:pure-syntax} *}
406 subsection {* Priority grammars \label{sec:priority-grammar} *}
408 text {* A context-free grammar consists of a set of \emph{terminal
409 symbols}, a set of \emph{nonterminal symbols} and a set of
410 \emph{productions}. Productions have the form @{text "A = \<gamma>"},
411 where @{text A} is a nonterminal and @{text \<gamma>} is a string of
412 terminals and nonterminals. One designated nonterminal is called
413 the \emph{root symbol}. The language defined by the grammar
414 consists of all strings of terminals that can be derived from the
415 root symbol by applying productions as rewrite rules.
417 The standard Isabelle parser for inner syntax uses a \emph{priority
418 grammar}. Each nonterminal is decorated by an integer priority:
419 @{text "A\<^sup>(\<^sup>p\<^sup>)"}. In a derivation, @{text "A\<^sup>(\<^sup>p\<^sup>)"} may be rewritten
420 using a production @{text "A\<^sup>(\<^sup>q\<^sup>) = \<gamma>"} only if @{text "p \<le> q"}. Any
421 priority grammar can be translated into a normal context-free
422 grammar by introducing new nonterminals and productions.
424 \medskip Formally, a set of context free productions @{text G}
425 induces a derivation relation @{text "\<longrightarrow>\<^sub>G"} as follows. Let @{text
426 \<alpha>} and @{text \<beta>} denote strings of terminal or nonterminal symbols.
427 Then @{text "\<alpha> A\<^sup>(\<^sup>p\<^sup>) \<beta> \<longrightarrow>\<^sub>G \<alpha> \<gamma> \<beta>"} holds if and only if @{text G}
428 contains some production @{text "A\<^sup>(\<^sup>q\<^sup>) = \<gamma>"} for @{text "p \<le> q"}.
430 \medskip The following grammar for arithmetic expressions
431 demonstrates how binding power and associativity of operators can be
432 enforced by priorities.
435 \begin{tabular}{rclr}
436 @{text "A\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>)"} & @{text "="} & @{verbatim "("} @{text "A\<^sup>(\<^sup>0\<^sup>)"} @{verbatim ")"} \\
437 @{text "A\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>)"} & @{text "="} & @{verbatim 0} \\
438 @{text "A\<^sup>(\<^sup>0\<^sup>)"} & @{text "="} & @{text "A\<^sup>(\<^sup>0\<^sup>)"} @{verbatim "+"} @{text "A\<^sup>(\<^sup>1\<^sup>)"} \\
439 @{text "A\<^sup>(\<^sup>2\<^sup>)"} & @{text "="} & @{text "A\<^sup>(\<^sup>3\<^sup>)"} @{verbatim "*"} @{text "A\<^sup>(\<^sup>2\<^sup>)"} \\
440 @{text "A\<^sup>(\<^sup>3\<^sup>)"} & @{text "="} & @{verbatim "-"} @{text "A\<^sup>(\<^sup>3\<^sup>)"} \\
443 The choice of priorities determines that @{verbatim "-"} binds
444 tighter than @{verbatim "*"}, which binds tighter than @{verbatim
445 "+"}. Furthermore @{verbatim "+"} associates to the left and
446 @{verbatim "*"} to the right.
448 \medskip For clarity, grammars obey these conventions:
451 \item All priorities must lie between 0 and 1000.
453 \item Priority 0 on the right-hand side and priority 1000 on the
454 left-hand side may be omitted.
456 \item The production @{text "A\<^sup>(\<^sup>p\<^sup>) = \<alpha>"} is written as @{text "A = \<alpha>
457 (p)"}, i.e.\ the priority of the left-hand side actually appears in
458 a column on the far right.
460 \item Alternatives are separated by @{text "|"}.
462 \item Repetition is indicated by dots @{text "(\<dots>)"} in an informal
467 Using these conventions, the example grammar specification above
470 \begin{tabular}{rclc}
471 @{text A} & @{text "="} & @{verbatim "("} @{text A} @{verbatim ")"} \\
472 & @{text "|"} & @{verbatim 0} & \qquad\qquad \\
473 & @{text "|"} & @{text A} @{verbatim "+"} @{text "A\<^sup>(\<^sup>1\<^sup>)"} & @{text "(0)"} \\
474 & @{text "|"} & @{text "A\<^sup>(\<^sup>3\<^sup>)"} @{verbatim "*"} @{text "A\<^sup>(\<^sup>2\<^sup>)"} & @{text "(2)"} \\
475 & @{text "|"} & @{verbatim "-"} @{text "A\<^sup>(\<^sup>3\<^sup>)"} & @{text "(3)"} \\
481 subsection {* The Pure grammar *}
484 The priority grammar of the @{text "Pure"} theory is defined as follows:
486 %FIXME syntax for "index" (?)
487 %FIXME "op" versions of ==> etc. (?)
490 \begin{supertabular}{rclr}
492 @{syntax_def (inner) any} & = & @{text "prop | logic"} \\\\
494 @{syntax_def (inner) prop} & = & @{verbatim "("} @{text prop} @{verbatim ")"} \\
495 & @{text "|"} & @{text "prop\<^sup>(\<^sup>4\<^sup>)"} @{verbatim "::"} @{text type} & @{text "(3)"} \\
496 & @{text "|"} & @{text "any\<^sup>(\<^sup>3\<^sup>)"} @{verbatim "=?="} @{text "any\<^sup>(\<^sup>2\<^sup>)"} & @{text "(2)"} \\
497 & @{text "|"} & @{text "any\<^sup>(\<^sup>3\<^sup>)"} @{verbatim "=="} @{text "any\<^sup>(\<^sup>2\<^sup>)"} & @{text "(2)"} \\
498 & @{text "|"} & @{text "any\<^sup>(\<^sup>3\<^sup>)"} @{text "\<equiv>"} @{text "any\<^sup>(\<^sup>2\<^sup>)"} & @{text "(2)"} \\
499 & @{text "|"} & @{text "prop\<^sup>(\<^sup>3\<^sup>)"} @{verbatim "&&&"} @{text "prop\<^sup>(\<^sup>2\<^sup>)"} & @{text "(2)"} \\
500 & @{text "|"} & @{text "prop\<^sup>(\<^sup>2\<^sup>)"} @{verbatim "==>"} @{text "prop\<^sup>(\<^sup>1\<^sup>)"} & @{text "(1)"} \\
501 & @{text "|"} & @{text "prop\<^sup>(\<^sup>2\<^sup>)"} @{text "\<Longrightarrow>"} @{text "prop\<^sup>(\<^sup>1\<^sup>)"} & @{text "(1)"} \\
502 & @{text "|"} & @{verbatim "[|"} @{text prop} @{verbatim ";"} @{text "\<dots>"} @{verbatim ";"} @{text prop} @{verbatim "|]"} @{verbatim "==>"} @{text "prop\<^sup>(\<^sup>1\<^sup>)"} & @{text "(1)"} \\
503 & @{text "|"} & @{text "\<lbrakk>"} @{text prop} @{verbatim ";"} @{text "\<dots>"} @{verbatim ";"} @{text prop} @{text "\<rbrakk>"} @{text "\<Longrightarrow>"} @{text "prop\<^sup>(\<^sup>1\<^sup>)"} & @{text "(1)"} \\
504 & @{text "|"} & @{verbatim "!!"} @{text idts} @{verbatim "."} @{text prop} & @{text "(0)"} \\
505 & @{text "|"} & @{text "\<And>"} @{text idts} @{verbatim "."} @{text prop} & @{text "(0)"} \\
506 & @{text "|"} & @{verbatim OFCLASS} @{verbatim "("} @{text type} @{verbatim ","} @{text logic} @{verbatim ")"} \\
507 & @{text "|"} & @{verbatim SORT_CONSTRAINT} @{verbatim "("} @{text type} @{verbatim ")"} \\
508 & @{text "|"} & @{verbatim TERM} @{text logic} \\
509 & @{text "|"} & @{verbatim PROP} @{text aprop} \\\\
511 @{syntax_def (inner) aprop} & = & @{verbatim "("} @{text aprop} @{verbatim ")"} \\
512 & @{text "|"} & @{text "id | longid | var | "}@{verbatim "_"}@{text " | "}@{verbatim "..."} \\
513 & @{text "|"} & @{verbatim CONST} @{text "id | "}@{verbatim CONST} @{text "longid"} \\
514 & @{text "|"} & @{text "logic\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>) any\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>) \<dots> any\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>)"} & @{text "(999)"} \\\\
516 @{syntax_def (inner) logic} & = & @{verbatim "("} @{text logic} @{verbatim ")"} \\
517 & @{text "|"} & @{text "logic\<^sup>(\<^sup>4\<^sup>)"} @{verbatim "::"} @{text type} & @{text "(3)"} \\
518 & @{text "|"} & @{text "id | longid | var | "}@{verbatim "_"}@{text " | "}@{verbatim "..."} \\
519 & @{text "|"} & @{verbatim CONST} @{text "id | "}@{verbatim CONST} @{text "longid"} \\
520 & @{text "|"} & @{text "logic\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>) any\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>) \<dots> any\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>)"} & @{text "(999)"} \\
521 & @{text "|"} & @{verbatim "%"} @{text pttrns} @{verbatim "."} @{text "any\<^sup>(\<^sup>3\<^sup>)"} & @{text "(3)"} \\
522 & @{text "|"} & @{text \<lambda>} @{text pttrns} @{verbatim "."} @{text "any\<^sup>(\<^sup>3\<^sup>)"} & @{text "(3)"} \\
523 & @{text "|"} & @{verbatim TYPE} @{verbatim "("} @{text type} @{verbatim ")"} \\\\
525 @{syntax_def (inner) idt} & = & @{verbatim "("} @{text idt} @{verbatim ")"}@{text " | id | "}@{verbatim "_"} \\
526 & @{text "|"} & @{text id} @{verbatim "::"} @{text type} & @{text "(0)"} \\
527 & @{text "|"} & @{verbatim "_"} @{verbatim "::"} @{text type} & @{text "(0)"} \\\\
529 @{syntax_def (inner) idts} & = & @{text "idt | idt\<^sup>(\<^sup>1\<^sup>) idts"} & @{text "(0)"} \\\\
531 @{syntax_def (inner) pttrn} & = & @{text idt} \\\\
533 @{syntax_def (inner) pttrns} & = & @{text "pttrn | pttrn\<^sup>(\<^sup>1\<^sup>) pttrns"} & @{text "(0)"} \\\\
535 @{syntax_def (inner) type} & = & @{verbatim "("} @{text type} @{verbatim ")"} \\
536 & @{text "|"} & @{text "tid | tvar | "}@{verbatim "_"} \\
537 & @{text "|"} & @{text "tid"} @{verbatim "::"} @{text "sort | tvar "}@{verbatim "::"} @{text "sort | "}@{verbatim "_"} @{verbatim "::"} @{text "sort"} \\
538 & @{text "|"} & @{text "id | type\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>) id | "}@{verbatim "("} @{text type} @{verbatim ","} @{text "\<dots>"} @{verbatim ","} @{text type} @{verbatim ")"} @{text id} \\
539 & @{text "|"} & @{text "longid | type\<^sup>(\<^sup>1\<^sup>0\<^sup>0\<^sup>0\<^sup>) longid"} \\
540 & @{text "|"} & @{verbatim "("} @{text type} @{verbatim ","} @{text "\<dots>"} @{verbatim ","} @{text type} @{verbatim ")"} @{text longid} \\
541 & @{text "|"} & @{text "type\<^sup>(\<^sup>1\<^sup>)"} @{verbatim "=>"} @{text type} & @{text "(0)"} \\
542 & @{text "|"} & @{text "type\<^sup>(\<^sup>1\<^sup>)"} @{text "\<Rightarrow>"} @{text type} & @{text "(0)"} \\
543 & @{text "|"} & @{verbatim "["} @{text type} @{verbatim ","} @{text "\<dots>"} @{verbatim ","} @{text type} @{verbatim "]"} @{verbatim "=>"} @{text type} & @{text "(0)"} \\
544 & @{text "|"} & @{verbatim "["} @{text type} @{verbatim ","} @{text "\<dots>"} @{verbatim ","} @{text type} @{verbatim "]"} @{text "\<Rightarrow>"} @{text type} & @{text "(0)"} \\\\
546 @{syntax_def (inner) sort} & = & @{text "id | longid | "}@{verbatim "{}"} \\
547 & @{text "|"} & @{verbatim "{"} @{text "(id | longid)"} @{verbatim ","} @{text "\<dots>"} @{verbatim ","} @{text "(id | longid)"} @{verbatim "}"} \\
551 \medskip Here literal terminals are printed @{verbatim "verbatim"};
552 see also \secref{sec:inner-lex} for further token categories of the
553 inner syntax. The meaning of the nonterminals defined by the above
554 grammar is as follows:
558 \item @{syntax_ref (inner) any} denotes any term.
560 \item @{syntax_ref (inner) prop} denotes meta-level propositions,
561 which are terms of type @{typ prop}. The syntax of such formulae of
562 the meta-logic is carefully distinguished from usual conventions for
563 object-logics. In particular, plain @{text "\<lambda>"}-term notation is
564 \emph{not} recognized as @{syntax (inner) prop}.
566 \item @{syntax_ref (inner) aprop} denotes atomic propositions, which
567 are embedded into regular @{syntax (inner) prop} by means of an
568 explicit @{verbatim PROP} token.
570 Terms of type @{typ prop} with non-constant head, e.g.\ a plain
571 variable, are printed in this form. Constants that yield type @{typ
572 prop} are expected to provide their own concrete syntax; otherwise
573 the printed version will appear like @{syntax (inner) logic} and
574 cannot be parsed again as @{syntax (inner) prop}.
576 \item @{syntax_ref (inner) logic} denotes arbitrary terms of a
577 logical type, excluding type @{typ prop}. This is the main
578 syntactic category of object-logic entities, covering plain @{text
579 \<lambda>}-term notation (variables, abstraction, application), plus
580 anything defined by the user.
582 When specifying notation for logical entities, all logical types
583 (excluding @{typ prop}) are \emph{collapsed} to this single category
584 of @{syntax (inner) logic}.
586 \item @{syntax_ref (inner) idt} denotes identifiers, possibly
587 constrained by types.
589 \item @{syntax_ref (inner) idts} denotes a sequence of @{syntax_ref
590 (inner) idt}. This is the most basic category for variables in
591 iterated binders, such as @{text "\<lambda>"} or @{text "\<And>"}.
593 \item @{syntax_ref (inner) pttrn} and @{syntax_ref (inner) pttrns}
594 denote patterns for abstraction, cases bindings etc. In Pure, these
595 categories start as a merely copy of @{syntax (inner) idt} and
596 @{syntax (inner) idts}, respectively. Object-logics may add
597 additional productions for binding forms.
599 \item @{syntax_ref (inner) type} denotes types of the meta-logic.
601 \item @{syntax_ref (inner) sort} denotes meta-level sorts.
605 Here are some further explanations of certain syntax features.
609 \item In @{syntax (inner) idts}, note that @{text "x :: nat y"} is
610 parsed as @{text "x :: (nat y)"}, treating @{text y} like a type
611 constructor applied to @{text nat}. To avoid this interpretation,
612 write @{text "(x :: nat) y"} with explicit parentheses.
614 \item Similarly, @{text "x :: nat y :: nat"} is parsed as @{text "x ::
615 (nat y :: nat)"}. The correct form is @{text "(x :: nat) (y ::
616 nat)"}, or @{text "(x :: nat) y :: nat"} if @{text y} is last in the
617 sequence of identifiers.
619 \item Type constraints for terms bind very weakly. For example,
620 @{text "x < y :: nat"} is normally parsed as @{text "(x < y) ::
621 nat"}, unless @{text "<"} has a very low priority, in which case the
622 input is likely to be ambiguous. The correct form is @{text "x < (y
625 \item Constraints may be either written with two literal colons
626 ``@{verbatim "::"}'' or the double-colon symbol @{verbatim "\<Colon>"},
627 which actually looks exactly the same in some {\LaTeX} styles.
629 \item Dummy variables (written as underscore) may occur in different
634 \item A type ``@{text "_"}'' or ``@{text "_ :: sort"}'' acts like an
635 anonymous inference parameter, which is filled-in according to the
636 most general type produced by the type-checking phase.
638 \item A bound ``@{text "_"}'' refers to a vacuous abstraction, where
639 the body does not refer to the binding introduced here. As in the
640 term @{term "\<lambda>x _. x"}, which is @{text "\<alpha>"}-equivalent to @{text
643 \item A free ``@{text "_"}'' refers to an implicit outer binding.
644 Higher definitional packages usually allow forms like @{text "f x _
647 \item A schematic ``@{text "_"}'' (within a term pattern, see
648 \secref{sec:term-decls}) refers to an anonymous variable that is
649 implicitly abstracted over its context of locally bound variables.
650 For example, this allows pattern matching of @{text "{x. f x = g
651 x}"} against @{text "{x. _ = _}"}, or even @{text "{_. _ = _}"} by
652 using both bound and schematic dummies.
656 \item The three literal dots ``@{verbatim "..."}'' may be also
657 written as ellipsis symbol @{verbatim "\<dots>"}. In both cases this
658 refers to a special schematic variable, which is bound in the
659 context. This special term abbreviation works nicely with
660 calculational reasoning (\secref{sec:calculation}).
666 section {* Lexical matters \label{sec:inner-lex} *}
668 text {* The inner lexical syntax vaguely resembles the outer one
669 (\secref{sec:outer-lex}), but some details are different. There are
670 two main categories of inner syntax tokens:
674 \item \emph{delimiters} --- the literal tokens occurring in
675 productions of the given priority grammar (cf.\
676 \secref{sec:priority-grammar});
678 \item \emph{named tokens} --- various categories of identifiers etc.
682 Delimiters override named tokens and may thus render certain
683 identifiers inaccessible. Sometimes the logical context admits
684 alternative ways to refer to the same entity, potentially via
687 \medskip The categories for named tokens are defined once and for
688 all as follows, reusing some categories of the outer token syntax
689 (\secref{sec:outer-lex}).
692 \begin{supertabular}{rcl}
693 @{syntax_def (inner) id} & = & @{syntax_ref ident} \\
694 @{syntax_def (inner) longid} & = & @{syntax_ref longident} \\
695 @{syntax_def (inner) var} & = & @{syntax_ref var} \\
696 @{syntax_def (inner) tid} & = & @{syntax_ref typefree} \\
697 @{syntax_def (inner) tvar} & = & @{syntax_ref typevar} \\
698 @{syntax_def (inner) num} & = & @{syntax_ref nat}@{text " | "}@{verbatim "-"}@{syntax_ref nat} \\
699 @{syntax_def (inner) float_token} & = & @{syntax_ref nat}@{verbatim "."}@{syntax_ref nat}@{text " | "}@{verbatim "-"}@{syntax_ref nat}@{verbatim "."}@{syntax_ref nat} \\
700 @{syntax_def (inner) xnum} & = & @{verbatim "#"}@{syntax_ref nat}@{text " | "}@{verbatim "#-"}@{syntax_ref nat} \\
702 @{syntax_def (inner) xstr} & = & @{verbatim "''"} @{text "\<dots>"} @{verbatim "''"} \\
706 The token categories @{syntax (inner) num}, @{syntax (inner)
707 float_token}, @{syntax (inner) xnum}, and @{syntax (inner) xstr} are
708 not used in Pure. Object-logics may implement numerals and string
709 constants by adding appropriate syntax declarations, together with
710 some translation functions (e.g.\ see Isabelle/HOL).
712 The derived categories @{syntax_def (inner) num_const} and
713 @{syntax_def (inner) float_const} provide robust access to @{syntax
714 (inner) num}, and @{syntax (inner) float_token}, respectively: the
715 syntax tree holds a syntactic constant instead of a free variable.
719 section {* Syntax and translations \label{sec:syn-trans} *}
722 \begin{matharray}{rcl}
723 @{command_def "nonterminals"} & : & @{text "theory \<rightarrow> theory"} \\
724 @{command_def "syntax"} & : & @{text "theory \<rightarrow> theory"} \\
725 @{command_def "no_syntax"} & : & @{text "theory \<rightarrow> theory"} \\
726 @{command_def "translations"} & : & @{text "theory \<rightarrow> theory"} \\
727 @{command_def "no_translations"} & : & @{text "theory \<rightarrow> theory"} \\
731 'nonterminals' (name +)
733 ('syntax' | 'no\_syntax') mode? (constdecl +)
735 ('translations' | 'no\_translations') (transpat ('==' | '=>' | '<=' | rightleftharpoons | rightharpoonup | leftharpoondown) transpat +)
738 mode: ('(' ( name | 'output' | name 'output' ) ')')
740 transpat: ('(' nameref ')')? string
746 \item @{command "nonterminals"}~@{text c} declares a type
747 constructor @{text c} (without arguments) to act as purely syntactic
748 type: a nonterminal symbol of the inner syntax.
750 \item @{command "syntax"}~@{text "(mode) decls"} is similar to
751 @{command "consts"}~@{text decls}, except that the actual logical
752 signature extension is omitted. Thus the context free grammar of
753 Isabelle's inner syntax may be augmented in arbitrary ways,
754 independently of the logic. The @{text mode} argument refers to the
755 print mode that the grammar rules belong; unless the @{keyword_ref
756 "output"} indicator is given, all productions are added both to the
757 input and output grammar.
759 \item @{command "no_syntax"}~@{text "(mode) decls"} removes grammar
760 declarations (and translations) resulting from @{text decls}, which
761 are interpreted in the same manner as for @{command "syntax"} above.
763 \item @{command "translations"}~@{text rules} specifies syntactic
764 translation rules (i.e.\ macros): parse~/ print rules (@{text "\<rightleftharpoons>"}),
765 parse rules (@{text "\<rightharpoonup>"}), or print rules (@{text "\<leftharpoondown>"}).
766 Translation patterns may be prefixed by the syntactic category to be
767 used for parsing; the default is @{text logic}.
769 \item @{command "no_translations"}~@{text rules} removes syntactic
770 translation rules, which are interpreted in the same manner as for
771 @{command "translations"} above.
777 section {* Syntax translation functions \label{sec:tr-funs} *}
780 \begin{matharray}{rcl}
781 @{command_def "parse_ast_translation"} & : & @{text "theory \<rightarrow> theory"} \\
782 @{command_def "parse_translation"} & : & @{text "theory \<rightarrow> theory"} \\
783 @{command_def "print_translation"} & : & @{text "theory \<rightarrow> theory"} \\
784 @{command_def "typed_print_translation"} & : & @{text "theory \<rightarrow> theory"} \\
785 @{command_def "print_ast_translation"} & : & @{text "theory \<rightarrow> theory"} \\
789 ( 'parse\_ast\_translation' | 'parse\_translation' | 'print\_translation' |
790 'typed\_print\_translation' | 'print\_ast\_translation' ) ('(advanced)')? text
794 Syntax translation functions written in ML admit almost arbitrary
795 manipulations of Isabelle's inner syntax. Any of the above commands
796 have a single \railqtok{text} argument that refers to an ML
797 expression of appropriate type, which are as follows by default:
799 %FIXME proper antiquotations
801 val parse_ast_translation : (string * (ast list -> ast)) list
802 val parse_translation : (string * (term list -> term)) list
803 val print_translation : (string * (term list -> term)) list
804 val typed_print_translation :
805 (string * (bool -> typ -> term list -> term)) list
806 val print_ast_translation : (string * (ast list -> ast)) list
809 If the @{text "(advanced)"} option is given, the corresponding
810 translation functions may depend on the current theory or proof
811 context. This allows to implement advanced syntax mechanisms, as
812 translations functions may refer to specific theory declarations or
813 auxiliary proof data.
815 See also \cite{isabelle-ref} for more information on the general
816 concept of syntax transformations in Isabelle.
818 %FIXME proper antiquotations
820 val parse_ast_translation:
821 (string * (Proof.context -> ast list -> ast)) list
822 val parse_translation:
823 (string * (Proof.context -> term list -> term)) list
824 val print_translation:
825 (string * (Proof.context -> term list -> term)) list
826 val typed_print_translation:
827 (string * (Proof.context -> bool -> typ -> term list -> term)) list
828 val print_ast_translation:
829 (string * (Proof.context -> ast list -> ast)) list
834 section {* Inspecting the syntax *}
837 \begin{matharray}{rcl}
838 @{command_def "print_syntax"}@{text "\<^sup>*"} & : & @{text "context \<rightarrow>"} \\
843 \item @{command "print_syntax"} prints the inner syntax of the
844 current context. The output can be quite large; the most important
845 sections are explained below.
849 \item @{text "lexicon"} lists the delimiters of the inner token
850 language; see \secref{sec:inner-lex}.
852 \item @{text "prods"} lists the productions of the underlying
853 priority grammar; see \secref{sec:priority-grammar}.
855 The nonterminal @{text "A\<^sup>(\<^sup>p\<^sup>)"} is rendered in plain text as @{text
856 "A[p]"}; delimiters are quoted. Many productions have an extra
857 @{text "\<dots> => name"}. These names later become the heads of parse
858 trees; they also guide the pretty printer.
860 Productions without such parse tree names are called \emph{copy
861 productions}. Their right-hand side must have exactly one
862 nonterminal symbol (or named token). The parser does not create a
863 new parse tree node for copy productions, but simply returns the
864 parse tree of the right-hand symbol.
866 If the right-hand side of a copy production consists of a single
867 nonterminal without any delimiters, then it is called a \emph{chain
868 production}. Chain productions act as abbreviations: conceptually,
869 they are removed from the grammar by adding new productions.
870 Priority information attached to chain productions is ignored; only
871 the dummy value @{text "-1"} is displayed.
873 \item @{text "print modes"} lists the alternative print modes
874 provided by this grammar; see \secref{sec:print-modes}.
876 \item @{text "parse_rules"} and @{text "print_rules"} relate to
877 syntax translations (macros); see \secref{sec:syn-trans}.
879 \item @{text "parse_ast_translation"} and @{text
880 "print_ast_translation"} list sets of constants that invoke
881 translation functions for abstract syntax trees, which are only
882 required in very special situations; see \secref{sec:tr-funs}.
884 \item @{text "parse_translation"} and @{text "print_translation"}
885 list the sets of constants that invoke regular translation
886 functions; see \secref{sec:tr-funs}.