23.1 val declarations : $\,\langle$ valDecl $\rangle\,$

Syntax of val declarations is given below.

$\,\langle$ valDecl $\rangle\,$	::=	val $\,\langle$ tyvarSeq $\rangle\,$ $\,\langle$ valBind $\rangle\,$
$\,\langle$ valBind $\rangle\,$	::=	$\,\langle$ valBind1 $\rangle\,$
	$\|$	$\,\langle$ valBind1 $\rangle\,$ and $\,\langle$ valBind $\rangle\,$
$\,\langle$ valBind1 $\rangle\,$	::=	$\,\langle$ pat $\rangle\,$ = $\,\langle$ exp $\rangle\,$

In this declaration, the variables appearing in patterns $\,\langle$ valBind $\rangle\,$ must be distinct. These variables are simultaneously defined, whose scope is the entire $\,\langle$ valDecl $\rangle\,$ declaration and the declarations that follows.

The type variable declaration $\,\langle$ tyvarSeq $\rangle\,$ in $\,\langle$ valDecl $\rangle\,$ delimit their scope. These type variables must be generalized at the top-level of each $\,\langle$ valBind1 $\rangle\,$ declaration.

23.1.1 val declaration interface : $\,\langle$ valSpec $\rangle\,$

For each variable defined in a val declaration, the following form of interface specification must be declared.

$\,\langle$ valBindInterface

$\rangle\,$

::=

val

$\,\langle$ id

$\rangle\,$ :

$\,\langle$ ty

$\rangle\,$

For example，for val declaration

val (x,y) = (1,2)

the following two interface specification must be given.

val x : int
val y : int

23.1.2 val declaration evaluation

Val declaration of the form

val $\,\langle$ pat ${}_{1}$ $\rangle\,$ = $\,\langle$ exp ${}_{1}$ $\rangle\,$ and $\,\langle$ pat ${}_{2}$ $\rangle\,$ = $\,\langle$ exp ${}_{2}$ $\rangle\,$ $\cdots$

is evaluated in the following two steps.

Structured pattern evaluating

A val declaration with a structured pattern $\,\langle$ pat $\rangle\,$ is first transformed to sequence of val declarations for the set $\{x_{1},\ldots,x_{m}\}$ of variables in the pattern $\,\langle$ pat $\rangle\,$ .

If the pattern $\,\langle$ pat $\rangle\,$ does not contain constructor or constant, then the transformation is done by recursively decompose $\,\langle$ pat ${}_{i}$ $\rangle\,$ and $\,\langle$ exp ${}_{i}$ $\rangle\,$ pair to a sequence of pairs of a sub-pattern and a sub-expression. This is done in the following steps.

1.

Each pattern $\,\langle$ pat ${}_{i}$ $\rangle\,$ is decomposed into sub-patterns according to the structure of $\,\langle$ pat ${}_{i}$ $\rangle\,$ . When $\,\langle$ pat ${}_{i}$ $\rangle\,$ has a type constraint, then the corresponding type constraint is attached to each of the decomposed sub-patterns.
2.

For each decomposed sub-pattern of $\,\langle$ pat ${}_{i}$ $\rangle\,$ , the corresponding sub-expression is generated from the expression $\,\langle$ exp ${}_{i}$ $\rangle\,$ by applying the code to extract the corresponding value to $\,\langle$ exp ${}_{i}$ $\rangle\,$ .
3.

If a sub-pattern is a layered pattern of the form $\mathit{id}$ as $\mathit{pat}$ , the additional code to bind $i d$ to the entire value is generated.
4.

Finally, the following from of val declarations is generated from the sequence of pairs of a variable and an expression obtained from the above transformation steps.

val $x_{1}$ $($ $:\tau_{1}$ $)?$ = $\mathit{exp}_{1}$
$\cdots$
and $x_{m}$ $($ $:\tau_{m}$ $)?$ = $\mathit{exp}_{m}$

This decomposition process enables the variables in structured patterns to have rank-1 polymorphic types as far as possible. However, the above transformation cannot be applied to val declarations with constructors and constants, since these val declarations may raise exception at runtime. A val declaration containing constructors and constants is transformed to the following val declaration with a variable.

val $X$ = case ( $\,\langle$ exp ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ exp ${}_{n}$ $\rangle\,$ ) of
          ( $\,\langle$ pat ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ pat ${}_{n}$ $\rangle\,$ ) => ( $x_{1}$ , $\ldots$ , $x_{m}$ )
        | _ => raise Bind
val $x_{1}$ = #1 $X$
   $\cdots$
and $x_{m}$ = # $m$ $X$

23.1.3 Example of val declarations and interface

The following are simple examples in the interactive mode.

# val (x,y) = (print "SML#\n", fn x => fn y => (x,y));
SML#
val x = () : unit
val y = fn : [’a. ’a -> [’b. ’b -> ’a * ’b]]

# val (z, w, 1) = (print "SML#\n", fn x => fn y => (x,y), 1);
(interactive):2.8-2.8 Warning:
  (type inference 065) dummy type variable(s) are introduced due to value
  restriction in: y
(interactive):2.4-2.57 Warning: binding not exhaustive
  (x, y, 1) => ...
SML#
val z = () : unit
val w = fn : fn : ?X7 -> ?X6 -> ?X7 * ?X6

The following is a simple example of a source file and an interface file in separate compilation.

Version.sml file: val (version, releaseDate) = ("4.2.0", "2025-03-24")
Version.smi file: val version : string
val releaseDate : string