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); }