Match Statement

The match statement provides a means to select the actual value from an expression of choice type.

Use in an Option

A very common use of a match is to test if an option contains data or is just nil. Here is an example with a feature japanese_number that translates some numbers into corresponding text in Japanese. Since not all numbers are supported, the result is an option that is present only for those numbers supported.

A match statement is then used to test if the translated result is present:

japanese_number(i i32) option(String) =>
{
  arr array(option(String)) := [nil, "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"];
  if 1 <= i < arr.length
  {
    arr[i]
  }
  else
  {
    nil
  }
}

for
  i in 0..12
do
{
  j String := match (japanese_number(i))
    {
      s String => { s }
      nil      => { "translation failed" }
    }
  say("$i is $j")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
japanese_number(i i32) option(String) =>
{
  arr array(option(String)) := [nil, "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"];
  if 1 <= i < arr.length
  {
    arr[i]
  }
  else
  {
    nil
  }
}
for
  i in 0..12
do
{
  j String := match (japanese_number(i))
    {
      s String => { s }
      nil      => { "translation failed" }
    }
  say("$i is $j")
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

An alternative syntax for match is available using ? and |:

japanese_number(i i32) option(String) =>
{
  arr array(option(String)) := [nil, "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"];
  if 1 <= i < arr.length
  {
    arr[i];
  }
  else
  {
    nil;
  }
}

for
  i in 0..12;
do
{
  j := (japanese_number(i) ? s String => s;
                           | nil      => "translation failed");
  say("$i is $j");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
japanese_number(i i32) option(String) =>
{
  arr array(option(String)) := [nil, "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"];
  if 1 <= i < arr.length
  {
    arr[i];
  }
  else
  {
    nil;
  }
}
for
  i in 0..12;
do
{
  j := (japanese_number(i) ? s String => s;
                           | nil      => "translation failed");
  say("$i is $j");
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Use in a Choice Type

Here is an example of using a match in a function get_red that extracts the red part from a color given in RGB, RGBA or CMYK color encoding:

rgb  (r,g,b   i32) is { }
rgba (r,g,b,a i32) is { }
cmyk (c,m,y,k i32) is { }

red(color rgb | rgba | cmyk) =>
{
  match color
  {
    v rgb  =>  v.r
    v rgba => (v.r * v.a) / 255
    v cmyk => (255-v.c)*(255-v.k)/255
  }
}

white   := rgb(255,255,255)
magenta := cmyk(0,255,0,0)
grey    := rgba(255,255,255,127)

r1 := red(white)
r2 := red(grey)
r3 := red(magenta)

say("red(white)   is " + r1)
say("red(grey)    is " + r2)
say("red(magenta) is " + r3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
rgb  (r,g,b   i32) is { }
rgba (r,g,b,a i32) is { }
cmyk (c,m,y,k i32) is { }
red(color rgb | rgba | cmyk) =>
{
  match color
  {
    v rgb  =>  v.r
    v rgba => (v.r * v.a) / 255
    v cmyk => (255-v.c)*(255-v.k)/255
  }
}
white   := rgb(255,255,255)
magenta := cmyk(0,255,0,0)
grey    := rgba(255,255,255,127)
r1 := red(white)
r2 := red(grey)
r3 := red(magenta)
say("red(white)   is " + r1)
say("red(grey)    is " + r2)
say("red(magenta) is " + r3)
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Match and Type Arguments

As long as a match can be identified without ambiguity, generic parameters can be omitted in the matched type:

print (x array(String) | list(i32)) unit =>
{
  match x
  {
    a array => { say("array(String): {a.map(s->"\"$s\"");}"); }
    l list  => { say("list(int): $l"); }
  }
}

print(["A", "B", "C"]);
print(1 : (2 : (3 : nil)));

1
2
3
4
5
6
7
8
9
10
11
12
print (x array(String) | list(i32)) unit =>
{
  match x
  {
    a array => { say("array(String): {a.map(s->"\"$s\"");}"); }
    l list  => { say("list(int): $l"); }
  }
}
print(["A", "B", "C"]);
print(1 : (2 : (3 : nil)));
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

When there is ambiguity, however, this does not work:

print (x array(String) | array(i32) | list(i32)) unit =>
{
  match x
  {
    a array /* error! */ => { say("array: $a"); }
    l list               => { say("list(int): $l"); }
  }
}

print([$"A", "B", "C"]);
print([1, 2, 3]);
print(1 : (2 : (3 : nil)));

1
2
3
4
5
6
7
8
9
10
11
12
13
print (x array(String) | array(i32) | list(i32)) unit =>
{
  match x
  {
    a array /* error! */ => { say("array: $a"); }
    l list               => { say("list(int): $l"); }
  }
}
print([$"A", "B", "C"]);
print([1, 2, 3]);
print(1 : (2 : (3 : nil)));
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Instead, all generic variants need to be treated k:

print (x array(String) | array(i32) | list(i32)) unit =>
{
  match x
  {
    a array(String) => { say("array(String): {a.map(s->"\"$s\"");}"); }
    a array(i32)    => { say("array(i32): $a"); }
    l list  => { say("list(int): $l"); }
  }
}

print([$"A", "B", "C"]);
print([1, 2, 3]);
print(1 : (2 : (3 : nil)));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
print (x array(String) | array(i32) | list(i32)) unit =>
{
  match x
  {
    a array(String) => { say("array(String): {a.map(s->"\"$s\"");}"); }
    a array(i32)    => { say("array(i32): $a"); }
    l list  => { say("list(int): $l"); }
  }
}
print([$"A", "B", "C"]);
print([1, 2, 3]);
print(1 : (2 : (3 : nil)));
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Match and destructuring

Fuzion's match expression (currently) does not destructure the value: The value of a choice type can have one of several defined types, so a match matches these types, not their structure.

One can, however, destructure the value into a tuple in the next step, as shown here:

rgb  (r,g,b   i32) is { }
rgba (r,g,b,a i32) is { }
cmyk (c,m,y,k i32) is { }

red(color rgb | rgba | cmyk) =>
{
  match color
  {
    v rgb  => { (r,_,_  ) := v; r  }
    v rgba => { (R,_,_,A) := v; R*A/255 }
    v cmyk => { (c,_,_,k) := v; (255-c)*(255-k)/255 }
  }
}

white   := rgb(255,255,255)
magenta := cmyk(0,255,0,0)
grey    := rgba(255,255,255,127)

r1 := red(white)
r2 := red(grey)
r3 := red(magenta)

say("red(white)   is " + r1)
say("red(grey)    is " + r2)
say("red(magenta) is " + r3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
rgb  (r,g,b   i32) is { }
rgba (r,g,b,a i32) is { }
cmyk (c,m,y,k i32) is { }
red(color rgb | rgba | cmyk) =>
{
  match color
  {
    v rgb  => { (r,_,_  ) := v; r  }
    v rgba => { (R,_,_,A) := v; R*A/255 }
    v cmyk => { (c,_,_,k) := v; (255-c)*(255-k)/255 }
  }
}
white   := rgb(255,255,255)
magenta := cmyk(0,255,0,0)
grey    := rgba(255,255,255,127)
r1 := red(white)
r2 := red(grey)
r3 := red(magenta)
say("red(white)   is " + r1)
say("red(grey)    is " + r2)
say("red(magenta) is " + r3)
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

? :, postfix ?, etc.

TBW: The ternary operator ? : is currently not supported. Since type bool is a choice type, it seems to make sense to generalize ? : to work on arbitrary values of a choice type.

Similarly, postfix ? could be used to extract the first type of a choice and otherwise return the value immediately from the current feature. Then, we could do things like

  read_int i32 | eof | error => ...

  read_point Point | eof | error =>
    Point read_int? read_int?

to propagate the end-of-file or error conditions. This would be a generalization of the ? operator in Rust that, as I understand, supports enums Option and Result only.

last changed: 2025-01-29

next: Conditional Expression