Return to reference.tex CVS log

Up to [Research Unix] / researchv10no / cmd / sml / doc / refman

researchv10 Norman

\chapter{Reference values}
\label{reference}
References are cells whose contents may be changed after creation by
assignment.  The \verb"ref" ``datatype'' constructor, and its
corresponding value constructor, are almost as if defined by the declaration
\begin{verbatim}
datatype 'a ref = ref of 'a
\end{verbatim}
Thus, a reference whose initial contents are the string \verb|"abc"|
may be created by \verb|val r = ref "abc"|.  Subsequently, the
contents of \verb"r" may be altered by assignment: \verb|r := "def"|.
The contents of a reference may be examined by using the \verb"ref"
constructor in a pattern:
\begin{verbatim}
let val (ref s) = r
 in print s
end
\end{verbatim}
The function \verb"!" is defined to take the contents of a reference;
that is,
\begin{verbatim}
fun ! (ref x) = x
\end{verbatim}

References are not fully polymorphic; see Chapter~\ref{reftype}.

Formally, we say that phrases in ML are evaluated in the presence of
an {\em environment} $E$ and a {\em store} $S$.  The effect on $E$ of
evaluating declarations, expressions, etc.  is described in
Chapter~\ref{eval}.  Here we summarize the effect on $S$.

The store $S$ maps reference values to their contents.  Evaluation of
an expression in the store $S$ yields, depending on the form of the
expression,
\begin{description}
\item[\verb"ref" exp\hfill] exp is evaluated in $S$,
producing a value $v$ and a store $S'$; the 
reference value $r$ is returned with the store $S'+\{r \mapsto v\}$.

\item[${\rm exp}_1$~${\rm exp}_2$\hfill]  ${\rm exp}_1$ is evaluated in $S$
yielding the function $f_1$ and store $S'$;
${\rm exp}_2$ is evaluated in $S'$ yielding $v_2$ and $S''$;
finally the body of $f_1$ is evaluated with its variable bound to $v_2$,
in the store $S''$, yielding the result $v$ and the store $S'''$.

\item[\verb"op := "$({\rm exp}_1,{\rm exp}_2)$\hfill]  The expression 
$({\rm exp}_1,{\rm exp}_2)$ is evaluated in $S$, yielding the pair
$(r,v)$ and the store $S'$; then the unit value \{\} is returned with
the store $S'+\{r \mapsto v\}$.

\item[\protect\verb"\{" ${\rm lab}_1$ \protect\verb"=" ${\rm exp}_1$ , \underline{\ \ \ } , ${\rm lab}_n$ \protect\verb"=" ${\rm exp}_n$ \protect\verb"\}" \hfill]  
${\rm exp}_1$ is evaluated in $S$, yielding $v_1$ and the store
$S_1$; then each ${\rm exp}_i$ is evaluated in $S_{i-1}$, yielding $v_i$ and the store $S_i$; then the record
$\{ {\rm lab}_1 = v_1 , ... , {\rm lab}_n = v_n \}$ is returned with
the store $S_n$.  Note that the expressions are evaluated in the
sequence they are written, not in alphabetical order of the labels.

\item[\protect\verb"raise" exp\hfill]  exp is evaluated in $S$, returning $v$
and $S'$; then the exception-packet $(v,S')$ is raised.

\item[exp \verb"handle" match\hfill]  exp is evaluated; if exp returns a
value $v$ with state $S'$, then $v$ is returned with $S'$.  
If exp raises an exception-packet $(e,S'')$ then
the match is applied to $e$ in the state $S''$.
If the match fails, then $(e,S'')$ is raised
(as the value of the \verb"handle" expression).  If the match
succeeds, then the resulting value is returned.
\end{description}

Matching a pattern to a value has no effect on the store.  Evaluating
a value binding has an effect on the store just from the evaluation of
the constituent expressions.  Evaluation of type, datatype, or exception
bindings has no effect on the store.

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.