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.

An example, that does not work yet: 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.

Demo
{
  monoid<T>
  {
    abstract zero T;
    abstract add (a, b T) T;
  }

  accum<T> (a Array<T>, m monoid<T>) T
  {
    for
      result = m.zero, m.add(result, x);
      x in a;
  }

  sum : monoid<i32>
  {
    zero => 0;
    add (a, b i32) => a + b;
  }

  product : monoid<i32>
  {
    zero => 1;
    add (a, b i32) => a * b;
  }

  i32array := [ 23, 345 , 3, 1, 3 ];
  totalSum     := accum<i32>(i32array, sum)
  totalProduct := accum<i32>(i32array, product)
}

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:

Demo
{
  accumSum (a Array<i32>) i32
  {
    for
      result = 0, result + x;
      x in a;
  }

  accumProduct (a Array<i32>) i32
  {
    for
      result = 1, result * x;
      x in a;
  }

  i32array := [ 23, 345 , 3, 1, 3 ];
  totalSum     := accumSum(i32array)
  totalProduct := accumProduct(i32array)

}

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

trigo
{
  sin(a f64) f64 { ... }
  cos(a f64) f64 { ... }
  tan(a f64) f64 { ... }
}

These can now be called using their qualified name

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

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

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

In case complex is exported as a public part of a module, we might not want to expose the fact that it inherits from trigo for implementation purposes, so we can inherit in private:

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