SML# Document Version 4.0.0

III Reference manual 19.25 Case branch expression with dynamic type cast _dynamiccase

\,\langle

\rangle\,

\,\langle

match

\rangle\,

21 Scope rules for identifier

Chapter 20 Patterns and Pattern Matching

Patterns $\,\langle$ pat $\rangle\,$ describe structures of values, and are used to bind variables values through pattern matching mechanism, built-in val-bind declarations (valBind)23.1, function declarations (funDecl)23.2, case expressions， fn expression，and handle expressions.

When evaluated, pattern matching generates static type environment at compile time, and dynamic value environment at runtime. These environments are used to added to the evaluation environment for the expressions and declarations in the scope of the pattern.

Syntax of Patterns is given below.

•

top-level pattern

$\,\langle$ pat $\rangle\,$	::=	$\,\langle$ atpat $\rangle\,$
	$\|$	$($ op $)?$ $\,\langle$ longVid $\rangle\,$ $\,\langle$ atpat $\rangle\,$	data structure
	$\|$	$\,\langle$ pat $\rangle\,$ $\,\langle$ vid $\rangle\,$ $\,\langle$ pat $\rangle\,$	data structure (infix operator form)
	$\|$	$\,\langle$ pat $\rangle\,$ : $\,\langle$ ty $\rangle\,$	pattern with type constraint
	$\|$	$\,\langle$ vid $\rangle\,$ $($ : $\,\langle$ ty $\rangle\,$ $)?$ as $\,\langle$ pat $\rangle\,$	layered pattern

•

atomic patterns

$\,\langle$ atpat $\rangle\,$	::=	$\,\langle$ scon $\rangle\,$	constant
	$\|$	_	anonymous pattern
	$\|$	$\,\langle$ vid $\rangle\,$	variable and constructor
	$\|$	$\,\langle$ longVid $\rangle\,$	constructor
	$\|$	{ $($ $\,\langle$ patrow $\rangle\,$ $)?$ }	record pattern
	$\|$	()	unit type constant
	$\|$	( $\,\langle$ pat ${}_{1}$ $\rangle\,$ , $\cdots$ , $\,\langle$ pat ${}_{n}$ $\rangle\,$ )	tuples ( $n\geq 2$ )
	$\|$	[ $\,\langle$ pat ${}_{1}$ $\rangle\,$ , $\cdots$ , $\,\langle$ pat ${}_{n}$ $\rangle\,$ ]	list ( $n\geq 0$ )
	$\|$	( $\,\langle$ pat $\rangle\,$ )
$\,\langle$ patrow $\rangle\,$	::=	`...`	anonymous field
	$\|$	$\,\langle$ lab $\rangle\,$ = $\,\langle$ pat $\rangle\,$ $($ , $\,\langle$ patrow $\rangle\,$ $)?$	record fields
	$\|$	vid $($ : $\,\langle$ ty $\rangle\,$ $)?$ $($ as $\,\langle$ pat $\rangle\,$ $)?$ $($ , $\,\langle$ patrow $\rangle\,$ $)?$	label and variable

The following subsections define for each pattern $\,\langle$ pat $\rangle\,$ , its type $\,\langle$ ty $\rangle\,$ , matching values, and the resulting type environment. The dynamic environment generated at runtime corresponds to the generated type environment and it binds identifiers to the matched values.

Constant pattern: $\,\langle$ scon $\rangle\,$

They are the same the constant expressions defined in 19.2. They have the corresponding types, match the same constant values, and generate the empty type environment.

Anonymous pattern:_

This has arbitrary type determined by the context, matches any value, and generates the empty type environment.

identifier pattern: $\,\langle$ vid $\rangle\,$

If the identifier is defined as a constructor, then it has the type of the constructor, matches the constructor, and generate the empty type environment.

If the identifier is not defined or defined as a variable, then it has arbitrary type $\,\langle$ ty $\rangle\,$ determined by the context, matches any value of type $\,\langle$ ty $\rangle\,$ , and generate the type environment $\{\mbox{$\,\langle$}{\it vid}\mbox{$\rangle\,$}:\mbox{$\,\langle$}{\it ty}% \mbox{$\rangle\,$}\}$ .

The following shows simple examples.

SML# 4.0.0 (2021-04-06) for x86_64-pc-linux-gnu with LLVM 11.1.0
# val A = 1
val A = 1 : int
# fn A => 1;
val it = fn : [’a. ’a -> int]
# datatype foo = A;
datatype foo = A
# fn A => 1;
val it = fn : foo -> int
# datatype foo = A of int;
datatype foo = x of int
# fn A => 1;
(interactive):12.3-12.3 Error:
(type inference 039) data constructor A used without argument in pattern

long identifier: $\,\langle$ longVid $\rangle\,$

If the long identifier is defined as a constructor, then it has the type of the constructor, matches the constructor, and generate the empty type environment. It is an error if the identifier is not defined as a constructor or defined as a constructor with an argument. The following shows simple examples.

# structure A = struct datatype foo = A | B of int val C = 1 end;
structure A =
  struct
    datatype foo = A | B of int
    val C = 1 : int
  end
# val f = fn A.A => 1;
val f = fn : A.foo -> int
# val g = fn A.B => 1;
(interactive):3.11-3.13 Error:
  (type inference 046) data constructor A.B used without argument in pattern
# val h = fn A.C => 1;
(interactive):4.11-4.13 Error: (name evaluation "020") unbound constructor: A.C

A.B is a constructor with an argument and A.C is a variable, function declarations g and h result in errors.

record pattern: $\,\langle$ { $($ $\,\langle$ patrow $\rangle\,$ $)?$ } $\rangle\,$

The pattern {} without record fields has the unit type, matches the value (), and generate the empty type environment.

If it has of the form $\,\langle$ lab ${}_{1}$ $\rangle\,$ : $\,\langle$ ty ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ lab ${}_{n}$ $\rangle\,$ : $\,\langle$ ty ${}_{n}$ $\rangle\,$ ， with non-empty record fields, there are two cases according to the record field pattern $\,\langle$ patrow $\rangle\,$ . Let $\Gamma$ be the type environment generated by the set of patterns in the fields.

1.

Monomorphic record pattern, i.e. the case where the anonymous field ... is not contained. It has the (monomorphic) record type { $\,\langle$ lab ${}_{1}$ $\rangle\,$ : $\,\langle$ ty ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ lab ${}_{n}$ $\rangle\,$ : $\,\langle$ ty ${}_{n}$ $\rangle\,$ }, matches any records containing all the fields that matches the record field patterns $\,\langle$ patrow $\rangle\,$ , and generate $\Gamma$ .
2.

Polymorphic record pattern, i.e. the case where the anonymous field ... is contained. It has the polymorphic record type ’a#{ $\,\langle$ lab ${}_{1}$ $\rangle\,$ : $\,\langle$ ty ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ lab ${}_{n}$ $\rangle\,$ : $\,\langle$ ty ${}_{n}$ $\rangle\,$ } with the record kind of the field types of $\,\langle$ patrow $\rangle\,$ , matches any records containing all the fields that matches the record field patterns $\,\langle$ patrow $\rangle\,$ , and generate $\Gamma$ . The polymorphic type of this entire pattern can be instantiated with any record types having the kind.

record field pattern: $\,\langle$ patrow $\rangle\,$

•

Anonymous field pattern : ...． It indicates that matching records may contains more fields than the specified fields.
•

Field pattern : $\,\langle$ lab $\rangle\,$ = $\,\langle$ pat $\rangle\,$ $($ , $\,\langle$ patrow $\rangle\,$ $)?$ . Let the filed type and the generated type environment of $($ , $\,\langle$ patrow $\rangle\,$ $)?$ be $\,\langle$ lab ${}_{1}$ $\rangle\,$ : $\,\langle$ ty ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ lab ${}_{n}$ $\rangle\,$ : $\,\langle$ ty ${}_{n}$ $\rangle\,$ , and $\Gamma$ . Let the type and the generated type environment of the pattern $\,\langle$ pat $\rangle\,$ be $\,\langle$ ty $\rangle\,$ and $\Gamma_{0}$ . If the label $\,\langle$ lab $\rangle\,$ is different than any labels $\,\langle$ lab ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ lab ${}_{n}$ $\rangle\,$ , then the type and the generated type environment of the entire pattern are $\,\langle$ lab $\rangle\,$ : $\,\langle$ ty $\rangle\,$ , $\,\langle$ lab ${}_{1}$ $\rangle\,$ : $\,\langle$ ty ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ lab ${}_{n}$ $\rangle\,$ : $\,\langle$ ty ${}_{n}$ $\rangle\,$ ， and $\Gamma_{0}\cup\Gamma$ . It is a type error if the label $\,\langle$ lab $\rangle\,$ is one of $\,\langle$ lab ${}_{1}$ $\rangle\,$ , $\ldots$ , $\,\langle$ lab ${}_{n}$ $\rangle\,$ .
•

variable as label pattern： vid $($ : $\,\langle$ ty $\rangle\,$ $)?$ $($ as $\,\langle$ pat $\rangle\,$ $)?$ $($ , $\,\langle$ patrow $\rangle\,$ $)?$ ．

This is converted to the following field pattern before evaluation.

vid = vid $($ : $\,\langle$ ty $\rangle\,$ $)?$ $($ as $\,\langle$ pat $\rangle\,$ $)?$ $($ , $\,\langle$ patrow $\rangle\,$ $)?$ ．

The generated static environment and the matching dynamic value are the same as the transformed record pattern. The following shows simple examples.

# val f = fn {x:int as 1, y} => x + y;
(interactive):33.8-33.34 Warning: match nonexhaustive
{x = x as 1, y = y} => ...
val f = fn : {x: int, y: int} -> int
# val g = fn {x = x:int as 1, y = y} => x + y;
(interactive):34.8-34.37 Warning: match nonexhaustive
{x = x as 1, y = y} => ...
val g = fn : {x: int, y: int} -> int
# f {x = 1, y = 2};
val it = 3 : int
# g {x = 1, y = 2};
val it = 3 : int

Tuple pattern:( $\,\langle$ pat ${}_{1}$ $\rangle\,$ , $\cdots$ , $\,\langle$ pat ${}_{n}$ $\rangle\,$ )

This is converted to the monomorphic record pattern

{1= $\,\langle$ pat ${}_{1}$ $\rangle\,$ , $\cdots$ ,n= $\,\langle$ pat ${}_{n}$ $\rangle\,$ }.

The generated static environment and the matching dynamic value are the same as the transformed record pattern. The following shows simple examples.

# val f = fn (x,y) => 2 * x + y;
val f = fn : int * int -> int
# val g = fn {1=x, 2=y} => 2 * x + y;
val g = fn : int * int -> int
# f 1=1, 2=2;
val it = 4 : int
# g (1,2);
val it = 4 : int

List pattern:[ $\,\langle$ pat ${}_{1}$ $\rangle\,$ , $\cdots$ , $\,\langle$ pat ${}_{n}$ $\rangle\,$ ]

This is converted to the following nested list data structure pattern:

$\,\langle$ pat ${}_{1}$ $\rangle\,$ :: $\cdots$ :: $\,\langle$ pat ${}_{n}$ $\rangle\,$ :: nil

The generated static environment and the matching dynamic value are the same as the transformed constructor application pattern. The following shows simple examples.

# val f = fn [x,y] => 2 * x + y;
(interactive):24.8-24.26 Warning: match nonexhaustive
:: (x, :: (y, nil )) => ...
val f = fn : int list -> int
# val g = fn (x::y::nil) => 2 * x + y;
(interactive):25.8-25.32 Warning: match nonexhaustive
:: (x, :: (y, nil )) => ...
val g = fn : int list -> int
# f (1::2::nil);
val it = 4 : int
# g [1,2];
val it = 4 : int

Data structure pattern: $($ op $)?$ $\,\langle$ longVid $\rangle\,$ $\,\langle$ atpat $\rangle\,$

If $\,\langle$ longVid $\rangle\,$ is bound to a constructor $C$ of type of the form $\,\langle$ ty ${}_{1}$ $\rangle\,$ -> $\,\langle$ ty ${}_{2}$ $\rangle\,$ ，then it has type $\,\langle$ ty ${}_{2}$ $\rangle\,$ and generates a type constructor generated by $\,\langle$ atpat $\rangle\,$ . This pattern matches a data structure of the form $C(v)$ if the subterm $v$ matches $\,\langle$ atpat $\rangle\,$ .

Data structure patter in infix form $\,\langle$ pat ${}_{1}$ $\rangle\,$ $\,\langle$ vid $\rangle\,$ $\,\langle$ pat ${}_{2}$ $\rangle\,$ is syntactically converted to op $\,\langle$ vid $\rangle\,$ ( $\,\langle$ pat ${}_{1}$ $\rangle\,$ , $\,\langle$ pat ${}_{2}$ $\rangle\,$ ) before evaluation. The type and type environment being generated and the matching dynamic value are the same as those of converted pattern.

Typed pattern: $\,\langle$ pat $\rangle\,$ : $\,\langle$ ty $\rangle\,$

If pattern $\,\langle$ pat $\rangle\,$ has type $\,\langle$ ty ${}_{1}$ $\rangle\,$ ad type environment $\Gamma_{0}$ , and $\,\langle$ ty ${}_{1}$ $\rangle\,$ and $\,\langle$ ty $\rangle\,$ unifies under type substitution $S$ , then this pattern has type $S(\mbox{$\,\langle$}{\it ty}\mbox{$\rangle\,$})$ and type environment $S(\Gamma_{0})$ . This pattern matches a value of type $S(\mbox{$\,\langle$}{\it ty}\mbox{$\rangle\,$})$ that matches pattern $\,\langle$ pat $\rangle\,$ .

Layered pattern: $\,\langle$ vid $\rangle\,$ $($ : $\,\langle$ ty $\rangle\,$ $)?$ as $\,\langle$ pat $\rangle\,$

If the pattern $\,\langle$ pat $\rangle\,$ : $\,\langle$ ty $\rangle\,$ has type $\,\langle$ ty ${}^{\prime}$ $\rangle\,$ and a type environment $\Gamma$ then this pattern has type $\,\langle$ ty ${}^{\prime}$ $\rangle\,$ and a type environment $\Gamma\cup\{x:\mbox{$\,\langle$}{\it ty^{\prime}}\mbox{$\rangle\,$}\}$ . It matches a dynamic value that the pattern $\,\langle$ pat $\rangle\,$ : $\,\langle$ ty $\rangle\,$ matches.

Chapter 20 Patterns and Pattern Matching

Constant pattern:⟨scon⟩

Anonymous pattern:_

identifier pattern:⟨vid⟩

long identifier:⟨longVid⟩

record pattern:⟨{(⟨patrow⟩)? }⟩

record field pattern:⟨patrow⟩

Tuple pattern:(⟨pat1⟩,⋯,⟨patn⟩)

List pattern:[⟨pat1⟩,⋯,⟨patn⟩]

Data structure pattern:(op)? ⟨longVid⟩ ⟨atpat⟩

Typed pattern: ⟨pat⟩:⟨ty⟩

Layered pattern: ⟨vid⟩ (: ⟨ty⟩)? as ⟨pat⟩