Unit Types

A unit type is a type that has only one single value.

In Fuzion, unit types can be used to structure an application similar to Java/C# packages as a means of encapsulation and information hiding. Also, they can be used to avoid overhead since assigning a value of a unit type is a NOP. Used as a generic argument, one can use these types to specialize code.

The unit type features sum and product are used to specialize the generic feature accum to calculate the total sum or the total product of an array of integers.

demo1_unit_types is
{
  Demo_Monoid (T type) ref is
  {
    zero T => abstract;
    add (a, b T) T => abstract;
  }

  accum (T type, a array T, m Demo_Monoid T) T =>
  {
    for
      res := m.zero, m.add res x;
      x in a;
    else
      {
        res;
      }
  }

  sum : Demo_Monoid i32 is
  {
    redef zero => { 0; }
    redef add (a, b i32) => { a + b; }
  }

  product : Demo_Monoid i32 is
  {
    redef zero => { 1; }
    redef add (a, b i32) => { a * b; }
  }

  i32array     := [ 23, 345 , 3, 1, 3 ];
  total_sum     => accum(i32, i32array, sum);
  total_product => accum(i32, i32array, product);
}

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
27
28
29
30
31
32
33
34
35
36
demo1_unit_types is
{
  Demo_Monoid (T type) ref is
  {
    zero T => abstract;
    add (a, b T) T => abstract;
  }
  accum (T type, a array T, m Demo_Monoid T) T =>
  {
    for
      res := m.zero, m.add res x;
      x in a;
    else
      {
        res;
      }
  }
  sum : Demo_Monoid i32 is
  {
    redef zero => { 0; }
    redef add (a, b i32) => { a + b; }
  }
  product : Demo_Monoid i32 is
  {
    redef zero => { 1; }
    redef add (a, b i32) => { a * b; }
  }
  i32array     := [ 23, 345 , 3, 1, 3 ];
  total_sum     => accum(i32, i32array, sum);
  total_product => accum(i32, i32array, product);
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

The fuzion compiler will specialize the calls to accum and produce code similar to the following. The unit type instances of sum and product disappear:

demo2_unit_types is
{
  accum_sum(a array i32) i32 =>
  {
    for
      res := 0, res + x;
      x in a;
    else
      {
        res;
      }
  }

  accum_product(a array i32) i32 =>
  {
    for
      res := 1, res * x;
      x in a;
    else
      {
        res
      }
  }

  i32array     := [ 23, 345 , 3, 1, 3 ];
  total_sum     => accum_sum i32array;
  total_product => accum_product i32array;
}

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
27
28
29
demo2_unit_types is
{
  accum_sum(a array i32) i32 =>
  {
    for
      res := 0, res + x;
      x in a;
    else
      {
        res;
      }
  }
  accum_product(a array i32) i32 =>
  {
    for
      res := 1, res * x;
      x in a;
    else
      {
        res
      }
  }
  i32array     := [ 23, 345 , 3, 1, 3 ];
  total_sum     => accum_sum i32array;
  total_product => accum_product i32array;
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Another Application of unit types are library features. Say you have a set of trigonometry functions:

demo3_trigo is
{
  trigo is
  {
    sin(x f64) f64 =>
    {
      x.sin;
    }

    cos(x f64) f64 =>
    {
      x.cos;
    }

    tan(x f64) f64 =>
    {
      x.tan;
    }
  }

  # sin, cos, tan can now be called using their qualified name

  complex(r f64, theta f64) is
  {
    x => r * trigo.cos theta;
    y => r * trigo.sin theta;
  }

  a := complex 1 0;
  b := complex 1 1;
  c := complex 1 3.1415;

  say "{a.x} {a.y}";
  say "{b.x} {b.y}";
  say "{c.x} {c.y}";
}

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
27
28
29
30
31
32
33
34
35
36
37
demo3_trigo is
{
  trigo is
  {
    sin(x f64) f64 =>
    {
      x.sin;
    }
    cos(x f64) f64 =>
    {
      x.cos;
    }
    tan(x f64) f64 =>
    {
      x.tan;
    }
  }
  # sin, cos, tan can now be called using their qualified name
  complex(r f64, theta f64) is
  {
    x => r * trigo.cos theta;
    y => r * trigo.sin theta;
  }
  a := complex 1 0;
  b := complex 1 1;
  c := complex 1 3.1415;
  say "{a.x} {a.y}";
  say "{b.x} {b.y}";
  say "{c.x} {c.y}";
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

Alternatively, by making complex inherit from trigo, we can add all of its features to our namespace:

demo4_trigo is
{
  trigo is
  {
    sin(x f64) f64 =>
    {
      x.sin;
    }

    cos(x f64) f64 =>
    {
      x.cos;
    }

    tan(x f64) f64 =>
    {
      x.tan;
    }
  }

  complex(r f64, theta f64) : trigo is
  {
    x => r * cos theta;
    y => r * sin theta;
  }

  a := complex 1 0;
  b := complex 1 1;
  c := complex 1 3.1415;

  say "{a.x} {a.y}";
  say "{b.x} {b.y}";
  say "{c.x} {c.y}";
}

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
27
28
29
30
31
32
33
34
35
demo4_trigo is
{
  trigo is
  {
    sin(x f64) f64 =>
    {
      x.sin;
    }
    cos(x f64) f64 =>
    {
      x.cos;
    }
    tan(x f64) f64 =>
    {
      x.tan;
    }
  }
  complex(r f64, theta f64) : trigo is
  {
    x => r * cos theta;
    y => r * sin theta;
  }
  a := complex 1 0;
  b := complex 1 1;
  c := complex 1 3.1415;
  say "{a.x} {a.y}";
  say "{b.x} {b.y}";
  say "{c.x} {c.y}";
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

What are effects?

last changed: 2024-06-28

next: Inheritance