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