Documentation
analysis -- condition qualifier for conditions used by static analysis tools
analysis is a condition qualifier that is used for conditions that are
not intended to be checked at run time but only by static analysis tools.
array -- one-dimensional immutable array
§array2<T>(length0 i32, length1 i32, init2 Function<array2.T, i32, i32>) => array2<array2.T>:array<T>
array(length0, length1)
array provides two-dimensional immutable arrays. These are actually
one-dimensional immutable arrays with an additional access function with
two index parameters.
§array3<T>(length0 i32, length1 i32, length2 i32, init3 Function<array3.T, i32, i32, i32>) => array3<array3.T>:array<T>
array(length0, length1, length2)
array provides three-dimensional immutable arrays. These are actually
one-dimensional immutable arrays with an additional access function with
three index parameters.
bitset -- persistent set of unsigned integers
bitsets -- unit type defining features related to bitest but not
requiring an instance
bool -- Standard Fuzion type 'bool'
We need to apologize to George Boole for crippling his name a bit,
just to safe us from typing one more letter. But at least we stop
here and do not use boo, bo or similar.
codepoint represents a unicode codepoint
codepoints is a unit type defining helper features to work with codepoint
complex -- returns value of unit type complexes
This is a convenience feature that allows using, e.g.,
'complex<i32>.sum' to get the the monoid of (complex, infix +) instead of
'complexs.sum'.
Since this complex with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with complex with two
arguments).
complexes -- unit type defining features related to complex
complexes is a unit type defining features related to complex but not
requiring an instance.
The plural form of complex is complexes or complices (archaic), according
to https://www.wordhippo.com/what-is/the-plural-of/complex.html, so we
use complexes.
Cons -- feature used to define abstract Cons cells
A Cons is a ref to a cell that contains a head and a tail
cons -- feature used to define simple, non-lazy Cons cells
A cons is a cell that contains a head and a tail
conststring -- feature used for string constants in Fuzion source code
conststring cannot be called directly, instances are created implicitly by the
backend.
debug is a condition qualifier that enables conditions if debugging is
enabled.
Current debug level, used by condition qualified debug(i32)
error represents an error condition described by a message string
NYI: Future versions of error might be equipped with a stack trace if
debugging is enabled
f32 -- 32 bit floating point values
f32 are binary32-numbers as defined in the IEEE 754-2019 standard, see
https://ieeexplore.ieee.org/servlet/opac?punumber=8766227
f32s -- unit type defining features related to f32 but not requiring an
instance
f32 are binary32-numbers as defined in the IEEE 754-2019 standard, see
https://ieeexplore.ieee.org/servlet/opac?punumber=8766227
f64 -- 64 bit floating point values
f64 are binary64-numbers as defined in the IEEE 754-2019 standard, see
https://ieeexplore.ieee.org/servlet/opac?punumber=8766227
f64s -- unit type defining features related to f64 but not requiring an
instance
f64 are binary64-numbers as defined in the IEEE 754-2019 standard, see
https://ieeexplore.ieee.org/servlet/opac?punumber=8766227
boolean value "false"
Note that this value is of unit type >>FALSE<<, not of type >>bool<<, i.e.,
if it is used for type inference as in
myBoolean := FALSE
you will get a variable of type >>FALSE<<, it will not be possible to assign
>>TRUE<< to it. You can use >>false<< as an alternative to get type >>bool<<.
float -- floating point values
float is the abstract parent of concrete floating point features such as
f32 or f64.
floats -- unit type defining features related to float but not requiring
an instance
floats are binary floating point numbers as defined in the IEEE 754-2019
standard, see https://ieeexplore.ieee.org/servlet/opac?punumber=8766227
fraction -- a convenience routine to create a fraction with den = one
To create a fraction that represents a whole number such as
two := fraction 2 1
you can use this routine with one argument and write
two := fraction 2
Function -- generic function with arbitrary number of arguments and result
hasEquals -- feature that allows comparison using 'infix =' operator.
Features inheriting from this feature must be immutable. The operator
'infix =' provides a means to separate values into equivalence classes.
NYI: the compiler should check that features inheriting from this are
actually immutable.
hasHash -- feature for immutable values that have a hash function
NYI: the compiler should check that features inheriting from this are
actually immutable.
hashMap -- convenience routine to create an empty instance of hashMap
hasInterval -- feature for integers that can define an interval
i16 -- returns value of unit type i16s
This is a convenience feature that allows using, e.g., 'i16.sum' to
get the the monoid of (i16, infix +) instead of 'i16s.sum'.
since this i16 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with i16 with one
argument).
i16s -- unit type defining features related to i16 but not requiring an
instance
i32 -- returns value of unit type i32s
This is a convenience feature that allows using, e.g., 'i32.sum' to
get the the monoid of (i32, infix +) instead of 'i32s.sum'.
since this i32 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with i32 with one
argument).
i32s -- unit type defining features related to i32 but not requiring an
instance
i64 -- returns value of unit type i64s
This is a convenience feature that allows using, e.g., 'i64.sum' to
get the the monoid of (i64, infix +) instead of 'i64s.sum'.
since this i64 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with i64 with one
argument).
i64s -- unit type defining features related to i64 but not requiring an
instance
i8 -- returns value of unit type i8s
This is a convenience feature that allows using, e.g., 'i8.sum' to
get the the monoid of (i8, infix +) instead of 'i8s.sum'.
since this i8 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with i8 with one
argument).
i8s -- unit type defining features related to i8 but not requiring an
instance
InitArray -- convenience feature for array creation
NYI: Replace by better syntactic sugar in the Fuzion parser / front end.
integer
integer is the abstract ancestor of integer numbers that provides operations
from numeric plus a devision remainder operation %, bitwise logical operations,
shift operations and gcd. Also, integers can be used to build fractions.
List -- ancestor for features that can be converted to a 'list' or a
'stream'
NYI: rename this as 'Sequence' to avoid confusion with 'list'
list -- feature used to define lists
list provides an abstract type for a sequence of elements of the same type.
A list sequence may be empty and contain no element, or it may have a fixed
or even infitie number of elements.
The core of the implementation of an actual list lies in the implementation
of the actual Cons cell a non-empty list consists of.
Lists can typically be traversed using only immutable data. This makes them
more flexible than streams that require to store and update their state.
Lists -- unit type defining features related to List but not requiring
an instance
lists -- unit type defining features related to list but not requiring an
instance
map -- an abstract map from keys K to values V
mapOf -- routine to initialize a map from arrays of ordered elements
and values
This feature creates an instance of a map.
marray -- one-dimensional mutable array
This feature provides a convenient constructor for marray<T>(length,
sys.array<T>, unit).
matrices -- unit type defining features related to matrix
matrices is a unit type defining features related to matrix but not
requiring an instance.
matrix -- matrix based on arbitrary numeric type
matrix provides matrix operations based on an arbitray numeric type
monad -- generic monad
A monad in X is just a monoid in the category of endofunctors of X, with
product × replaced by composition of endofunctors and unit set by the
identity endofunctor.
-- Saunder Mac Lane, Categories for the Working Mathematician, 1971
Don't be scared, in Java terms: A monad is a means to compose functions
applied to generic types.
Monoid -- parent feature for monoids
A monoid is an abstraction for a type with an associative operation and
an identity element. Examples are (integers/infix +/0), (float/infix *,1),
(string/concat/""), etc.
nil -- value for options that are not present
This is a unit type that is preferred to represent instances that are
not present, e.g, in an option.
numeric -- parent of all numeric features
numerics -- unit type defining features related to numeric but not
requiring an instance
numOption -- optional numeric values
This is a pseudo-numeric type that handles one additional
value: nil. Any operation on nil will result in nil for a
numeric result or false for a boolean result.
Object -- parent feature of all features that do not have an explicit parent
option represents an optional value of type T
ordered -- feature for immutable values that have an infix <= function
predicate that defines a total order
features inheriting from ordered define a total order of their values
NYI: the compiler should check that features inheriting from this are
actually immutable.
orderedMap -- convenience routine to create an empty instance of orderedMap
outcome is a choice type that represents the result of a routine that
may either produce something useful or fail producing an error condition.
Several error conditions are needed if there are several very different
reasons for an operation to fail, e.g.
getData (u User, t Type) outcome<data, IOError, PermissionError> is
if u.allowedToAcces T
(readFile t.fileName)?
else
PermissionError u, t
readFile t Type outcome<data, IOError> is
[..]
Note that 'outcome<data, IOError>' is not assignment compatible with
'outcome<data, IOError, PermissionError>', it has to be unwrapped first.
This unwrapping, however, requires very little boilerplate, it is done
using the '?' on the result of the call to 'readFile': This unwraps
'outcome<data, IOError>' into 'IOError', which would be returned abruptly,
and 'data', which would be returned normally. Both are assignment
compatible to 'outcome<data, IOError, PermissionError>', so everything
is fine.
partiallyOrdered -- feature for immutable values that have an infix <=
predicate that defines a partial order
features inheriting from partiallyOrdered define a partial order of their
values
NYI: the compiler should check that features inheriting from this are
actually immutable.
pedantic -- condition qualifier for conditions that are pedantic
pedantic is a condition qualifier for conditions a pedantic purist would require,
but that a more relaxed hacker would prefer to do without.
psMap -- a partially sorted map
See psMap.fz for details.
This feature creates an empty instance of psMap.
psSet -- a partially sorted set based on psMap
See psSet.fz for details.
This feature creates an empty instance of psSet.
quantors provides forAll and exists-quantors for use in contracts qualified
for analysis.
pedantic -- condition qualifier for conditions that are required for safety
safety is a condition qualifier that is used for conditions that are
absolutely required to ensure safety.
This must never be disabled if safety is of any concern. Applications
run with safety disabled typically have security vulnerabilities that
allow system takeover via manipulated input data.
searchableList -- a list whose elements inherit from hasEquals
In contrast to searchablelist, this uses ref type 'list' and not choice
type 'list', so it is more flexible.
searchablelist -- a list whose elements inherit from hasEquals
In contrast to searchableList, this uses choice type 'list' and not ref
type 'List', so it is more efficient.
Set -- an abstract set of values V
setOf -- routine to initialize an empty set of ordered elements
This feature creates an instance of a Set.
some is a standard wrapper for values of type T
sortedarray -- sorted one-dimensional immutable array of ordered elements
This takes an unsorted array as an argument and returns a sorted one using
the order defined by the type of the elements T.
See sortedArray(from, lessOrEqual) for details
A handy shortcut for stdout.print, output string representation of
an object, do not add a line break at the end.
NYI: there is also 'yak', which I currently prefer, but this needs some
native English speaker's advice.
stream -- a stream of values
NYI: Check if stream should be replaced by a lazy list, which is a choice
of either nil or a tuple (head, tail). This should avoid the need to store
mutable state.
string -- immutable sequences of utf8 encoded unicode characters
strings -- unit type defining features related to string but not
requiring an instance
sum -- generic sum of the elements of a List of numeric.
This should allow summing the elements of a list, as in
l := [1,2,3]
say sum l # 6
NYI: This is experimental and does not work yet
boolean value "true"
Note that this value is of unit type >>TRUE<<, not of type >>bool<<, i.e.,
if it is used for type inference as in
myBoolean := TRUE
you will get a variable of type >>TRUE<<, it will not be possible to assign
>>FALSE<< to it. You can use >>true<< as an alternative to get type >>bool<<.
u128 -- returns value of unit type u128s
This is a convenience feature that allows using, e.g., 'u128.sum' to
get the the monoid of (u128, infix +) instead of 'u128s.sum'.
since this u128 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with u128 with one
argument).
u128s -- unit type defining features related to u128 but not requiring an
instance
u16 -- returns value of unit type u16s
This is a convenience feature that allows using, e.g., 'u16.sum' to
get the the monoid of (u16, infix +) instead of 'u16s.sum'.
since this u16 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with u16 with one
argument).
u16s -- unit type defining features related to u16 but not requiring an
instance
u32 -- returns value of unit type u32s
This is a convenience feature that allows using, e.g., 'u32.sum' to
get the the monoid of (u32, infix +) instead of 'u32s.sum'.
since this u32 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with u32 with one
argument).
u32s -- unit type defining features related to u32 but not requiring an
instance
u64 -- returns value of unit type u64s
This is a convenience feature that allows using, e.g., 'u64.sum' to
get the the monoid of (u64, infix +) instead of 'u64s.sum'.
since this u64 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with u64 with one
argument).
u64s -- unit type defining features related to u64 but not requiring an
instance
u8 -- returns value of unit type u8s
This is a convenience feature that allows using, e.g., 'u8.sum' to
get the the monoid of (u8, infix +) instead of 'u8s.sum'.
since this u8 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with u8 with one
argument).
u8s -- unit type defining features related to u8 but not requiring an
instance
uint -- unsigned integer values of arbitrary size
unit -- value to be used as result of features that do not return a result
NOTE: unit corresponds to type void in C, Java, etc.
unit is the preferred result type for features that return without producing
a result value. These are features that typically have an outside effect
such as
println(String s) unit is ...
or features that change the state of an instance such as
increment(delta i64) unit is
set counter := counter + delta
The Fuzion language implementation automatically inserts code that returns the
unit value as a result of these features, there is no need for an explicit unit
result as in
increment(delta i64) unit is
set counter := counter + delta
unit
but it is allowed to return unit explicitly if desired.
Another application of the unit type are generic features when certain generic
values are not needed and can be ignored. An example could be a generic map
implementation map<K,V> that maps values of type K to values of type V. Using
unit as the actual generic argument for V, e.g., map<string,unit> creates a
map that stores no data for each key, which essentially turns the map into a
set of the map's keys.
The Fuzion library knows several different unit types. Another example is nil,
which is used as the alternative type in an option. This enables the use of
option<void>, which can store two distinct values, void and nil.
Other unit types in Fuzion are TRUE and FALSE.
The simplest syntax to create a value of unit type is an empty block '{}'. Note
that an empty tuple 'tuple<>' is a different unit value of a different type and
the syntax '()' is (at least for now) not supported.
Please note the fundamental difference between
red is {}
red => {}
The first declares a feature red that defines a new unit type red, the second
declares a feature red with result type unit, i.e., a synonyme for unit as in
red unit is {}
The memory required to store a value of unit type is 0 bits, so you can use
plenty without worrying about space constraints. The Fuzion code generators
typically will not generate any code for returning or assiging a value of unit
type, so these are very efficient as well.
void -- type with no values
NOTE: For a counterpart to void in C, Java, etc., see unit.fz
It is impossible to create any values of this type, consequently, it is impossible
to assign anything to a field of void type.
If used as the type of an argument field for a feature, the feature can never be
called since no value assignable to that argument could ever be produced. This
produces an absurd feature.
If used as the result type of a routine, the routine can never return.
void is the result type of the endless loop
do { <loop body> }
If used as the result type of a field, the field can never be assigned a value,
since no such value can be produced, and the field can never be read since it
remains not initialized forever.
Type void is assignable to all other types, e.g, we can assign void to a value
of type i32:
i i32 := fuzion.std.exit 1
Since no value of type void can ever be produced, the assignment is dead code that
will be removed by the fuzion implementation.
Type void may be used as an actual generic argument for a generic feature. If this
is done, it will turn all features that have arguments of that type into absurd
features. Also, this will ensure that any feature that produce a result of that
type to never return a result (typically to not be callable in the first place as
well). An example could be a stack of capacity zero: stack<void>(0) with an
absurd
stack.push(void)
and a pop function with a precondition that is always false
pop void
pre size > 0
The memory required to store a value of void type is not defined since these
values do not exist. The Fuzion code generators typically will not generate
any code for features receiving arguments of void type or for code following
a feature call that returns void.
wrappingInteger
wrappingInteger is the abstract ancestor of integer numbers that have min and
max values and operations with wrap-around semantics.
wrappingIntegers -- unit type defining features related to wrappingInteger
but not requiring an instance