OLD | NEW |
1 \documentclass{article} | 1 \documentclass{article} |
2 \usepackage{epsfig} | 2 \usepackage{epsfig} |
3 \usepackage{color} | 3 \usepackage{color} |
4 \usepackage{dart} | 4 \usepackage{dart} |
5 \usepackage{bnf} | 5 \usepackage{bnf} |
6 \usepackage{hyperref} | 6 \usepackage{hyperref} |
7 \usepackage{lmodern} | 7 \usepackage{lmodern} |
8 \newcommand{\code}[1]{{\sf #1}} | 8 \newcommand{\code}[1]{{\sf #1}} |
9 \title{Dart Programming Language Specification \\ | 9 \title{Dart Programming Language Specification \\ |
10 (4th edition draft)\\ | 10 (4th edition draft)\\ |
(...skipping 1789 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1800 \item Static members are never inherited. | 1800 \item Static members are never inherited. |
1801 \item It is a warning if you have an static member named $m$ in your class or a
ny superclass (even though it is not inherited) and an instance member of the s
ame name (\ref{instanceMethods}, \ref{getters}, \ref{setters}). | 1801 \item It is a warning if you have an static member named $m$ in your class or a
ny superclass (even though it is not inherited) and an instance member of the s
ame name (\ref{instanceMethods}, \ref{getters}, \ref{setters}). |
1802 \item It is a warning if you have a static setter $v=$, and an instance member $
v$ (\ref{setters}). | 1802 \item It is a warning if you have a static setter $v=$, and an instance member $
v$ (\ref{setters}). |
1803 \item It is a warning if you have a static getter $v$ and an instance setter $v=
$ (\ref{getters}). | 1803 \item It is a warning if you have a static getter $v$ and an instance setter $v=
$ (\ref{getters}). |
1804 \item If you define an instance member named $m$, and your superclass has an in
stance member of the same name, they override each other. This may or may not be
legal. | 1804 \item If you define an instance member named $m$, and your superclass has an in
stance member of the same name, they override each other. This may or may not be
legal. |
1805 \item \label{typeSigAssignable} | 1805 \item \label{typeSigAssignable} |
1806 If two members override each other, it is a static warning if their type signatu
res are not assignable to each other (\ref{instanceMethods}, \ref{getters}, \ref
{setters}) (and since these are function types, this means the same as "subtype
s of each other"). | 1806 If two members override each other, it is a static warning if their type signatu
res are not assignable to each other (\ref{instanceMethods}, \ref{getters}, \ref
{setters}) (and since these are function types, this means the same as "subtype
s of each other"). |
1807 \item \label{requiredParams} | 1807 \item \label{requiredParams} |
1808 If two members override each other, it is a static warning if the overriding mem
ber has more required parameters than the overridden one (\ref{instanceMethods}
). | 1808 If two members override each other, it is a static warning if the overriding mem
ber has more required parameters than the overridden one (\ref{instanceMethods}
). |
1809 \item \label{optionalPositionals} | 1809 \item \label{optionalPositionals} |
1810 If two members override each other, it is a static warning if the overriding mem
ber has fewer positional parameters than the the overridden one (\ref{instanceM
ethods}). | 1810 If two members override each other, it is a static warning if the overriding mem
ber has fewer positional parameters than the overridden one (\ref{instanceMetho
ds}). |
1811 \item \label{namedParams} | 1811 \item \label{namedParams} |
1812 If two members override each other, it is a static warning if the overriding mem
ber does not have all the named parameters that the the overridden one has (\ref
{instanceMethods}). | 1812 If two members override each other, it is a static warning if the overriding mem
ber does not have all the named parameters that the overridden one has (\ref{ins
tanceMethods}). |
1813 \item Setters, getters and operators never have optional parameters of any kind;
it's a compile-time error (\ref{operators}, \ref{getters}, \ref{setters}). | 1813 \item Setters, getters and operators never have optional parameters of any kind;
it's a compile-time error (\ref{operators}, \ref{getters}, \ref{setters}). |
1814 \item It is a compile-time error if a member has the same name as its enclosing
class (\ref{classes}). | 1814 \item It is a compile-time error if a member has the same name as its enclosing
class (\ref{classes}). |
1815 \item A class has an implicit interface (\ref{classes}). | 1815 \item A class has an implicit interface (\ref{classes}). |
1816 \item Superinterface members are not inherited by a class, but are inherited by
its implicit interface. Interfaces have their own inheritance rules (\ref{interf
aceInheritanceAndOverriding}). | 1816 \item Superinterface members are not inherited by a class, but are inherited by
its implicit interface. Interfaces have their own inheritance rules (\ref{interf
aceInheritanceAndOverriding}). |
1817 \item A member is abstract if it has no body and is not labeled \EXTERNAL{} (\re
f{abstractInstanceMembers}, \ref{externalFunctions}). | 1817 \item A member is abstract if it has no body and is not labeled \EXTERNAL{} (\re
f{abstractInstanceMembers}, \ref{externalFunctions}). |
1818 \item A class is abstract iff it is explicitly labeled \ABSTRACT{}.% or if it de
clares (not just inherits) an abstract member (\ref{classes}). | 1818 \item A class is abstract iff it is explicitly labeled \ABSTRACT{}.% or if it de
clares (not just inherits) an abstract member (\ref{classes}). |
1819 \item It is a static warning if a concrete class has an abstract member (declare
d or inherited). | 1819 \item It is a static warning if a concrete class has an abstract member (declare
d or inherited). |
1820 \item It is a static warning and a dynamic error to call a non-factory construct
or of an abstract class (\ref{new}). | 1820 \item It is a static warning and a dynamic error to call a non-factory construct
or of an abstract class (\ref{new}). |
1821 \item If a class defines an instance member named $m$, and any of its superinter
faces have a member named $m$, the interface of the class overrides $m$. | 1821 \item If a class defines an instance member named $m$, and any of its superinter
faces have a member named $m$, the interface of the class overrides $m$. |
1822 \item An interface inherits all members of its superinterfaces that are not ov
erridden and not members of multiple superinterfaces. | 1822 \item An interface inherits all members of its superinterfaces that are not ov
erridden and not members of multiple superinterfaces. |
1823 \item If multiple superinterfaces of an interface define a member with the same
name $m$, then at most one member is inherited. That member (if it exists) is t
he one whose type is a subtype of all the others. If there is no such member, th
en: | 1823 \item If multiple superinterfaces of an interface define a member with the same
name $m$, then at most one member is inherited. That member (if it exists) is t
he one whose type is a subtype of all the others. If there is no such member, th
en: |
1824 \begin{itemize} | 1824 \begin{itemize} |
1825 \item A static warning is given. | 1825 \item A static warning is given. |
1826 \item If possible the interface gets a member named $m$ that has the minimum
number of required parameters among all the members in the superinterfaces, the
maximal number of positionals, and the superset of named parameters. The typ
es of these are all \DYNAMIC{}. If this is impossible then no member $m$ appears
in the interface. | 1826 \item If possible the interface gets a member named $m$ that has the minimum
number of required parameters among all the members in the superinterfaces, the
maximal number of positionals, and the superset of named parameters. The typ
es of these are all \DYNAMIC{}. If this is impossible then no member $m$ appears
in the interface. |
1827 \end{itemize} (\ref{interfaceInheritanceAndOverriding}) | 1827 \end{itemize} (\ref{interfaceInheritanceAndOverriding}) |
1828 \item Rule \ref{typeSigAssignable} applies to interfaces as well as classes (\
ref{interfaceInheritanceAndOverriding}). | 1828 \item Rule \ref{typeSigAssignable} applies to interfaces as well as classes (\
ref{interfaceInheritanceAndOverriding}). |
1829 \item It is a static warning if a concrete class does not have an implementatio
n for a method in any of its superinterfaces unless it has a \cd{noSuchMethod}
method (\ref{superinterfaces}). | 1829 \item It is a static warning if a concrete class does not have an implementatio
n for a method in any of its superinterfaces unless it has a \cd{noSuchMethod}
method (\ref{superinterfaces}). |
1830 \item The identifier of a named constructor cannot be the same as the name of a
member declared (as opposed to inherited) in the same class (\ref{constructors})
. | 1830 \item The identifier of a named constructor cannot be the same as the name of a
member declared (as opposed to inherited) in the same class (\ref{constructors})
. |
1831 \end{enumerate} | 1831 \end{enumerate} |
1832 } | 1832 } |
1833 | 1833 |
1834 | 1834 |
1835 %Can we have abstract getters and setters? | 1835 %Can we have abstract getters and setters? |
1836 | 1836 |
1837 \subsection{ Superinterfaces} | 1837 \subsection{ Superinterfaces} |
1838 \LMLabel{superinterfaces} | 1838 \LMLabel{superinterfaces} |
1839 % what about rules about classes that fail to implement their interfaces? | 1839 % what about rules about classes that fail to implement their interfaces? |
1840 | 1840 |
1841 \LMHash{} | 1841 \LMHash{} |
1842 A class has a set of direct superinterfaces. This set includes the interface of
its superclass and the interfaces specified in the the \IMPLEMENTS{} clause of
the class. | 1842 A class has a set of direct superinterfaces. This set includes the interface of
its superclass and the interfaces specified in the \IMPLEMENTS{} clause of the
class. |
1843 % and any superinterfaces specified by interface injection (\ref{interfaceInject
ion}). \Q{The latter needs to be worded carefully - when do interface injection
clauses execute and in what scope?} | 1843 % and any superinterfaces specified by interface injection (\ref{interfaceInject
ion}). \Q{The latter needs to be worded carefully - when do interface injection
clauses execute and in what scope?} |
1844 | 1844 |
1845 \begin{grammar} | 1845 \begin{grammar} |
1846 {\bf interfaces:} | 1846 {\bf interfaces:} |
1847 \IMPLEMENTS{} typeList | 1847 \IMPLEMENTS{} typeList |
1848 . | 1848 . |
1849 \end{grammar} | 1849 \end{grammar} |
1850 | 1850 |
1851 \LMHash{} | 1851 \LMHash{} |
1852 The scope of the \IMPLEMENTS{} clause of a class $C$ is the type-parameter scope
of $C$. | 1852 The scope of the \IMPLEMENTS{} clause of a class $C$ is the type-parameter scope
of $C$. |
(...skipping 955 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2808 | 2808 |
2809 \end{grammar} | 2809 \end{grammar} |
2810 | 2810 |
2811 \LMHash{} | 2811 \LMHash{} |
2812 All string literals implement the built-in class \code{String}. It is a compile-
time error for a class to attempt to extend, mix in or implement \code{String}.
Invoking the getter \code{runtimeType} on a string literal returns the \code{Typ
e} object that is the value of the expression \code{String}. The static type of
a string literal is \code{String}. | 2812 All string literals implement the built-in class \code{String}. It is a compile-
time error for a class to attempt to extend, mix in or implement \code{String}.
Invoking the getter \code{runtimeType} on a string literal returns the \code{Typ
e} object that is the value of the expression \code{String}. The static type of
a string literal is \code{String}. |
2813 | 2813 |
2814 \subsubsection{String Interpolation} | 2814 \subsubsection{String Interpolation} |
2815 \LMLabel{stringInterpolation} | 2815 \LMLabel{stringInterpolation} |
2816 | 2816 |
2817 \LMHash{} | 2817 \LMHash{} |
2818 It is possible to embed expressions within non-raw string literals, such that th
e these expressions are evaluated, and the resulting values are converted into s
trings and concatenated with the enclosing string. This process is known as {\em
string interpolation}. | 2818 It is possible to embed expressions within non-raw string literals, such that th
ese expressions are evaluated, and the resulting values are converted into strin
gs and concatenated with the enclosing string. This process is known as {\em str
ing interpolation}. |
2819 | 2819 |
2820 \begin{grammar} | 2820 \begin{grammar} |
2821 {\bf stringInterpolation:}`\$' IDENTIFIER\_NO\_DOLLAR; | 2821 {\bf stringInterpolation:}`\$' IDENTIFIER\_NO\_DOLLAR; |
2822 `\$' `\{' expression `\}' % could be top level expression, no? | 2822 `\$' `\{' expression `\}' % could be top level expression, no? |
2823 . | 2823 . |
2824 \end{grammar} | 2824 \end{grammar} |
2825 | 2825 |
2826 \commentary{The reader will note that the expression inside the interpolation co
uld itself include strings, which could again be interpolated recursively. | 2826 \commentary{The reader will note that the expression inside the interpolation co
uld itself include strings, which could again be interpolated recursively. |
2827 } | 2827 } |
2828 | 2828 |
(...skipping 223 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3052 } | 3052 } |
3053 | 3053 |
3054 \LMHash{} | 3054 \LMHash{} |
3055 If $f$ is asynchronous then if there is a dynamically enclosing exception handl
er $h$ (\ref{try}) introduced by the current activation, control is transferred
to $h$, otherwise $f$ terminates. | 3055 If $f$ is asynchronous then if there is a dynamically enclosing exception handl
er $h$ (\ref{try}) introduced by the current activation, control is transferred
to $h$, otherwise $f$ terminates. |
3056 | 3056 |
3057 \rationale{ | 3057 \rationale{ |
3058 The rules for where a thrown exception will be handled must necessarily differ b
etween the synchronous and asynchronous cases. Asynchronous functions cannot tra
nsfer control to an exception handler defined outside themselves. Asynchronous
generators post exceptions to their stream. Other asynchronous functions report
exceptions via their future. | 3058 The rules for where a thrown exception will be handled must necessarily differ b
etween the synchronous and asynchronous cases. Asynchronous functions cannot tra
nsfer control to an exception handler defined outside themselves. Asynchronous
generators post exceptions to their stream. Other asynchronous functions report
exceptions via their future. |
3059 } | 3059 } |
3060 | 3060 |
3061 \LMHash{} | 3061 \LMHash{} |
3062 If the object being thrown is an instance of class \code{Error} or a subclass th
ereof, its \code{stackTrace} getter will return the stack trace current at the p
oint where the the object was first thrown. | 3062 If the object being thrown is an instance of class \code{Error} or a subclass th
ereof, its \code{stackTrace} getter will return the stack trace current at the p
oint where the object was first thrown. |
3063 | 3063 |
3064 \LMHash{} | 3064 \LMHash{} |
3065 The static type of a throw expression is $\bot$. | 3065 The static type of a throw expression is $\bot$. |
3066 | 3066 |
3067 | 3067 |
3068 \subsection{ Function Expressions} | 3068 \subsection{ Function Expressions} |
3069 \LMLabel{functionExpressions} | 3069 \LMLabel{functionExpressions} |
3070 | 3070 |
3071 \LMHash{} | 3071 \LMHash{} |
3072 A {\em function literal} is an object that encapsulates an executable unit of co
de. | 3072 A {\em function literal} is an object that encapsulates an executable unit of co
de. |
(...skipping 2603 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5676 | 5676 |
5677 \rationale{ | 5677 \rationale{ |
5678 The definition above is intended to prevent the common error where users create
a closure inside a for loop, intending to close over the current binding of the
loop variable, and find (usually after a painful process of debugging and learni
ng) that all the created closures have captured the same value - the one current
in the last iteration executed. | 5678 The definition above is intended to prevent the common error where users create
a closure inside a for loop, intending to close over the current binding of the
loop variable, and find (usually after a painful process of debugging and learni
ng) that all the created closures have captured the same value - the one current
in the last iteration executed. |
5679 | 5679 |
5680 Instead, each iteration has its own distinct variable. The first iteration uses
the variable created by the initial declaration. The expression executed at the
end of each iteration uses a fresh variable $v^{\prime\prime}$, bound to the va
lue of the current iteration variable, and then modifies $v^{\prime\prime}$ as r
equired for the next iteration. | 5680 Instead, each iteration has its own distinct variable. The first iteration uses
the variable created by the initial declaration. The expression executed at the
end of each iteration uses a fresh variable $v^{\prime\prime}$, bound to the va
lue of the current iteration variable, and then modifies $v^{\prime\prime}$ as r
equired for the next iteration. |
5681 } | 5681 } |
5682 | 5682 |
5683 \LMHash{} | 5683 \LMHash{} |
5684 It is a static warning if the static type of $c$ may not be assigned to \cd{bool
}. | 5684 It is a static warning if the static type of $c$ may not be assigned to \cd{bool
}. |
5685 | 5685 |
5686 %A for statement of the form \code{ \FOR{} ($d$ ; $c$; $e$) $s$} is equivalent t
o the the following code: | 5686 %A for statement of the form \code{ \FOR{} ($d$ ; $c$; $e$) $s$} is equivalent t
o the following code: |
5687 | 5687 |
5688 %\code{ | 5688 %\code{ |
5689 %\{$d$; | 5689 %\{$d$; |
5690 %\WHILE{} ($c$) \{ | 5690 %\WHILE{} ($c$) \{ |
5691 % \{$s$\} | 5691 % \{$s$\} |
5692 % $e$; | 5692 % $e$; |
5693 %\}\} | 5693 %\}\} |
5694 %} | 5694 %} |
5695 | 5695 |
5696 %If $c$ is empty, it is interpreted as \TRUE{}. | 5696 %If $c$ is empty, it is interpreted as \TRUE{}. |
(...skipping 602 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6299 \LMHash{} | 6299 \LMHash{} |
6300 The {\em break statement} consists of the reserved word \BREAK{} and an optional
label (\ref{labels}). | 6300 The {\em break statement} consists of the reserved word \BREAK{} and an optional
label (\ref{labels}). |
6301 | 6301 |
6302 \begin{grammar} | 6302 \begin{grammar} |
6303 {\bf breakStatement:} | 6303 {\bf breakStatement:} |
6304 \BREAK{} identifier? `{\escapegrammar ;}' | 6304 \BREAK{} identifier? `{\escapegrammar ;}' |
6305 . | 6305 . |
6306 \end{grammar} | 6306 \end{grammar} |
6307 | 6307 |
6308 \LMHash{} | 6308 \LMHash{} |
6309 Let $s_b$ be a \BREAK{} statement. If $s_b$ is of the form \code{\BREAK{} $L$;}
, then let $s_E$ be the the innermost labeled statement with label $L$ enclosing
$s_b$. If $s_b$ is of the form \code{\BREAK{};}, then let $s_E$ be the the inn
ermost \DO{} (\ref{do}), \FOR{} (\ref{for}), \SWITCH{} (\ref{switch}) or \WHILE
{} (\ref{while}) statement enclosing $s_b$. It is a compile-time error if no su
ch statement $s_E$ exists within the innermost function in which $s_b$ occurs.
Furthermore, let $s_1, \ldots, s_n$ be those \TRY{} statements that are both en
closed in $s_E$ and that enclose $s_b$, and that have a \FINALLY{} clause. Last
ly, let $f_j$ be the \FINALLY{} clause of $s_j, 1 \le j \le n$. Executing $s_
b$ first executes $f_1, \ldots, f_n$ in innermost-clause-first order and then
terminates $s_E$. | 6309 Let $s_b$ be a \BREAK{} statement. If $s_b$ is of the form \code{\BREAK{} $L$;}
, then let $s_E$ be the innermost labeled statement with label $L$ enclosing $s_
b$. If $s_b$ is of the form \code{\BREAK{};}, then let $s_E$ be the innermost
\DO{} (\ref{do}), \FOR{} (\ref{for}), \SWITCH{} (\ref{switch}) or \WHILE{} (\ref
{while}) statement enclosing $s_b$. It is a compile-time error if no such state
ment $s_E$ exists within the innermost function in which $s_b$ occurs. Further
more, let $s_1, \ldots, s_n$ be those \TRY{} statements that are both enclosed i
n $s_E$ and that enclose $s_b$, and that have a \FINALLY{} clause. Lastly, let
$f_j$ be the \FINALLY{} clause of $s_j, 1 \le j \le n$. Executing $s_b$ first
executes $f_1, \ldots, f_n$ in innermost-clause-first order and then terminat
es $s_E$. |
6310 | 6310 |
6311 \LMHash{} | 6311 \LMHash{} |
6312 If $s_E$ is an asynchronous for loop (\ref{asynchronousFor-in}), its associated
stream subscription is canceled. Furthermore, let $a_k$ be the set of asynchrono
us for loops and yield-each statements (\ref{yieldEach}) enclosing $s_b$ that a
re enclosed in $s_E , 1 \le k \le m$, where $a_k$ is enclosed in $a_{k+1}$. Th
e stream subscriptions associated with $a_j$ are canceled, $1 \le j \le m$, inne
rmost first, so that $a_j$ is canceled before $a_{j+1}$. | 6312 If $s_E$ is an asynchronous for loop (\ref{asynchronousFor-in}), its associated
stream subscription is canceled. Furthermore, let $a_k$ be the set of asynchrono
us for loops and yield-each statements (\ref{yieldEach}) enclosing $s_b$ that a
re enclosed in $s_E , 1 \le k \le m$, where $a_k$ is enclosed in $a_{k+1}$. Th
e stream subscriptions associated with $a_j$ are canceled, $1 \le j \le m$, inne
rmost first, so that $a_j$ is canceled before $a_{j+1}$. |
6313 | 6313 |
6314 | 6314 |
6315 | 6315 |
6316 \subsection{ Continue} | 6316 \subsection{ Continue} |
6317 \LMLabel{continue} | 6317 \LMLabel{continue} |
6318 | 6318 |
6319 \LMHash{} | 6319 \LMHash{} |
6320 The {\em continue statement} consists of the reserved word \CONTINUE{} and an op
tional label (\ref{labels}). | 6320 The {\em continue statement} consists of the reserved word \CONTINUE{} and an op
tional label (\ref{labels}). |
6321 | 6321 |
6322 \begin{grammar} | 6322 \begin{grammar} |
6323 {\bf continueStatement:} | 6323 {\bf continueStatement:} |
6324 \CONTINUE{} identifier? `{\escapegrammar ;}' | 6324 \CONTINUE{} identifier? `{\escapegrammar ;}' |
6325 . | 6325 . |
6326 \end{grammar} | 6326 \end{grammar} |
6327 | 6327 |
6328 \LMHash{} | 6328 \LMHash{} |
6329 Let $s_c$ be a \CONTINUE{} statement. If $s_c$ is of the form \code{\CONTINUE{
} $L$;}, then let $s_E$ be the the innermost labeled \DO{} (\ref{do}), \FOR{} (\
ref{for}) or \WHILE{} (\ref{while}) statement or case clause with label $L$ encl
osing $s_c$. If $s_c$ is of the form \code{\CONTINUE{};} then let $s_E$ be the
the innermost \DO{} (\ref{do}), \FOR{} (\ref{for}) or \WHILE{} (\ref{while}) st
atement enclosing $s_c$. It is a compile-time error if no such statement or cas
e clause $s_E$ exists within the innermost function in which $s_c$ occurs. Fur
thermore, let $s_1, \ldots, s_n$ be those \TRY{} statements that are both enclos
ed in $s_E$ and that enclose $s_c$, and that have a \FINALLY{} clause. Lastly,
let $f_j$ be the \FINALLY{} clause of $s_j, 1 \le j \le n$. Executing $s_c$ f
irst executes $f_1, \ldots, f_n$ in innermost-clause-first order. Then, if $s_
E$ is a case clause, control is transferred to the case clause. Otherwise, $s_E$
is necessarily a loop and execution resumes after the last statement in the loo
p body. | 6329 Let $s_c$ be a \CONTINUE{} statement. If $s_c$ is of the form \code{\CONTINUE{
} $L$;}, then let $s_E$ be the innermost labeled \DO{} (\ref{do}), \FOR{} (\ref{
for}) or \WHILE{} (\ref{while}) statement or case clause with label $L$ enclosin
g $s_c$. If $s_c$ is of the form \code{\CONTINUE{};} then let $s_E$ be the inne
rmost \DO{} (\ref{do}), \FOR{} (\ref{for}) or \WHILE{} (\ref{while}) statement
enclosing $s_c$. It is a compile-time error if no such statement or case clause
$s_E$ exists within the innermost function in which $s_c$ occurs. Furthermore
, let $s_1, \ldots, s_n$ be those \TRY{} statements that are both enclosed in $s
_E$ and that enclose $s_c$, and that have a \FINALLY{} clause. Lastly, let $f_j
$ be the \FINALLY{} clause of $s_j, 1 \le j \le n$. Executing $s_c$ first exe
cutes $f_1, \ldots, f_n$ in innermost-clause-first order. Then, if $s_E$ is a
case clause, control is transferred to the case clause. Otherwise, $s_E$ is nece
ssarily a loop and execution resumes after the last statement in the loop body. |
6330 | 6330 |
6331 \commentary{ | 6331 \commentary{ |
6332 In a while loop, that would be the boolean expression before the body. In a do
loop, it would be the boolean expression after the body. In a for loop, it would
be the increment clause. In other words, execution continues to the next itera
tion of the loop. | 6332 In a while loop, that would be the boolean expression before the body. In a do
loop, it would be the boolean expression after the body. In a for loop, it would
be the increment clause. In other words, execution continues to the next itera
tion of the loop. |
6333 } | 6333 } |
6334 | 6334 |
6335 \LMHash{} | 6335 \LMHash{} |
6336 If $s_E$ is an asynchronous for loop (\ref{asynchronousFor-in}), let $a_k$ be t
he set of asynchronous for loops and yield-each statements (\ref{yieldEach}) enc
losing $s_c$ that are enclosed in $s_E , 1 \le k \le m$, where $a_k$ is enclosed
in $a_{k+1}$. The stream subscriptions associated with $a_j$ are canceled, $1
\le j \le m$, innermost first, so that $a_j$ is canceled before $a_{j+1}$. | 6336 If $s_E$ is an asynchronous for loop (\ref{asynchronousFor-in}), let $a_k$ be t
he set of asynchronous for loops and yield-each statements (\ref{yieldEach}) enc
losing $s_c$ that are enclosed in $s_E , 1 \le k \le m$, where $a_k$ is enclosed
in $a_{k+1}$. The stream subscriptions associated with $a_j$ are canceled, $1
\le j \le m$, innermost first, so that $a_j$ is canceled before $a_{j+1}$. |
6337 | 6337 |
6338 \subsection{ Yield and Yield-Each} | 6338 \subsection{ Yield and Yield-Each} |
6339 \LMLabel{yieldAndYieldEach} | 6339 \LMLabel{yieldAndYieldEach} |
(...skipping 633 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6973 A URI of the form \code{dart:$s$} is interpreted as a reference to a system libr
ary (\ref{imports}) $s$. | 6973 A URI of the form \code{dart:$s$} is interpreted as a reference to a system libr
ary (\ref{imports}) $s$. |
6974 | 6974 |
6975 \LMHash{} | 6975 \LMHash{} |
6976 A URI of the form \code{package:$s$} is interpreted in an implementation specifi
c manner. | 6976 A URI of the form \code{package:$s$} is interpreted in an implementation specifi
c manner. |
6977 | 6977 |
6978 \rationale{ | 6978 \rationale{ |
6979 The intent is that, during development, Dart programmers can rely on a package m
anager to find elements of their program. | 6979 The intent is that, during development, Dart programmers can rely on a package m
anager to find elements of their program. |
6980 } | 6980 } |
6981 | 6981 |
6982 \LMHash{} | 6982 \LMHash{} |
6983 Otherwise, any relative URI is interpreted as relative to the the location of th
e current library. All further interpretation of URIs is implementation dependen
t. | 6983 Otherwise, any relative URI is interpreted as relative to the location of the cu
rrent library. All further interpretation of URIs is implementation dependent. |
6984 | 6984 |
6985 \commentary{This means it is dependent on the embedder.} | 6985 \commentary{This means it is dependent on the embedder.} |
6986 | 6986 |
6987 | 6987 |
6988 \section{Types} | 6988 \section{Types} |
6989 \LMLabel{types} | 6989 \LMLabel{types} |
6990 | 6990 |
6991 \LMHash{} | 6991 \LMHash{} |
6992 Dart supports optional typing based on interface types. | 6992 Dart supports optional typing based on interface types. |
6993 | 6993 |
(...skipping 874 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7868 | 7868 |
7869 The invariant that each normative paragraph is associated with a line | 7869 The invariant that each normative paragraph is associated with a line |
7870 containing the text \LMHash{} should be maintained. Extra occurrences | 7870 containing the text \LMHash{} should be maintained. Extra occurrences |
7871 of \LMHash{} can be added if needed, e.g., in order to make | 7871 of \LMHash{} can be added if needed, e.g., in order to make |
7872 individual \item{}s in itemized lists addressable. Each \LM.. command | 7872 individual \item{}s in itemized lists addressable. Each \LM.. command |
7873 must occur on a separate line. \LMHash{} must occur immediately | 7873 must occur on a separate line. \LMHash{} must occur immediately |
7874 before the associated paragraph, and \LMLabel must occur immediately | 7874 before the associated paragraph, and \LMLabel must occur immediately |
7875 after the associated \section{}, \subsection{} etc. | 7875 after the associated \section{}, \subsection{} etc. |
7876 | 7876 |
7877 ---------------------------------------------------------------------- | 7877 ---------------------------------------------------------------------- |
OLD | NEW |