☰
API-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.
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 -- create initialized one-dimensional immutable array
NYI: move this to 'arrays.new' or similar to avoid overloading
with 'array(T,internalArray,_,_,_)'.
NYI: move this to 'arrays.new' or similar to avoid overloading
with 'array(T,internalArray,_,_,_)'.
§array(T type, internalArray fuzion.sys.internal_array array.T, @1073865180 unit, @1073865230 unit, @1073865280 unit) => array array.T:Sequence array.T
§array(T
type
, internalArray fuzion.sys.internal_array array.T, @1073865180 unit, @1073865230 unit, @1073865280 unit) =>
array array.T:
Sequence array.Tarray -- one-dimensional immutable array
This is the result type of array(type, i32, i32 -> T) which creates an
initalized immutable array
NYI: This uses three dummy unit-type args (i.e. total of 5 args or 4 value
args) to avoid name clashes with routine array(T,length,init) (i.e., 3 args
or 2 value args). These unit-type args can go if the routine would be
moved to 'array.type.new' or 'arrays.new'
This is the result type of array(type, i32, i32 -> T) which creates an
initalized immutable array
NYI: This uses three dummy unit-type args (i.e. total of 5 args or 4 value
args) to avoid name clashes with routine array(T,length,init) (i.e., 3 args
or 2 value args). These unit-type args can go if the routine would be
moved to 'array.type.new' or 'arrays.new'
§array2(T type, length0 i32, length1 i32, init2 Function array2.T i32 i32) => array2 array2.T:array array2.T
§array2(T
type
, length0 i32, length1 i32, init2 Function array2.T i32 i32) =>
array2 array2.T:
array array2.Tarray(length0, length1) -- two-dimensional immutable array
array provides two-dimensional immutable arrays. These are actually
one-dimensional immutable arrays with an additional access function with
two index parameters.
array provides two-dimensional immutable arrays. These are actually
one-dimensional immutable arrays with an additional access function with
two index parameters.
§array3(T type, length0 i32, length1 i32, length2 i32, init3 Function array3.T i32 i32 i32) => array3 array3.T:array array3.T
§array3(T
type
, length0 i32, length1 i32, length2 i32, init3 Function array3.T i32 i32 i32) =>
array3 array3.T:
array array3.Tarray(length0, length1, length2) -- three-dimensional immutable array
array provides three-dimensional immutable arrays. These are actually
one-dimensional immutable arrays with an additional access function with
three index parameters.
array provides three-dimensional immutable arrays. These are actually
one-dimensional immutable arrays with an additional access function with
three index parameters.
benchmark f for milli_seconds (1s warm up)
only completed iterations are counted, any iterations started before
the one second warmup has elapsed are not counted either
returns: iterations per second
only completed iterations are counted, any iterations started before
the one second warmup has elapsed are not counted either
returns: iterations per second
benchmark f by iterating it for nano_seconds
only completed iterations are counted, any iterations started before
warm_up_nano_seconds has elapsed are not counted either
returns: iterations per second
only completed iterations are counted, any iterations started before
warm_up_nano_seconds has elapsed are not counted either
returns: iterations per second
bitset -- persistent set of unsigned integers
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.
bool is a choice type that can either be TRUE of FALSE.
Note that 'TRUE' and 'FALSE' themselves are not of type 'bool'.
Routines 'true' and 'false' are the preferred way to get a constant
value of 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.
bool is a choice type that can either be TRUE of FALSE.
Note that 'TRUE' and 'FALSE' themselves are not of type 'bool'.
Routines 'true' and 'false' are the preferred way to get a constant
value of type 'bool'.
cache result of f for cache key T
This is best explained by the following example:
The cache implemented works on a global level.
This is best explained by the following example:
The cache implemented works on a global level.
character_encodings -- unit feature to group character encodings
choice -- feature used for choice types
choice types provide algebraic sum types of all the generic arguments
provided to choice. A instance of a choice type is a tagged union of
the types provided as actual generic type parameters. This concept is
also called variant, sum type or coproduct in other contexts.
Syntactic sugar of the Fuzion language permits an alternative notation
for choice types with actual generics as follows
A | B | C | ...
which is equivalent to
choice A B C ...
The parser will directly convert the first notation into a choice type
with actual generics.
A field of choice type can be assigned a value of the same choice type
or of any of the actual generic type arguments provided to the choice
feature.
Two choice types choice A B and choice B A that differ only in the order
of their actual generic arguments are treated as different types.
Named choice types can be constructed through inheritance, i.e.,
C : choice A B is {}
creates a choice type of A and B with the name C. Two named choice types
D and E that inherit from choice with the same actual generic arguments in
the same order are nevertheless different types and their values are not
assignable to one another.
Named choice types may declare or inherit additional inner features as long
as these features are not fields. Also, declared inner features must not
build a closure that accesses outer features. Additional parents must be
unit types, i.e., they must not declare fields nor access features of any
of their outer features.
Note that all types provided must be distinct, it is not possible to
repeat the same type as in choice i32 i32 or float | float. If a sum
type of two or more equal types is desired, these types must first be
wrapped into a new type as illustrated in the following example:
Say we want to store a temperature that is given as a 32 bit integer
in degrees centigrade or degrees Fahrenheit. So we define two wrapper
features
centigrade(degrees i32) is {}
fahrenheit(degrees i32) is {}
Now we define the choice type using the wrapped i32 types, which are
distinct:
hasFever(temp centigrade | fahrenheit) bool is ...
When passing arguments to this feature, we need to wrap them accordingly:
hasFever (centigrade 37)
hasFever (fahrenheit 99)
When matching the choice type, we use the wrapper types and access the
argument field 'degrees' to access the i32 stored inside
match temp
NYI: Once Fuzion's match statement supports destructuring as well, we should
be able to extract the degrees directly as in
match temp
A choice type with no actual generic arguments is isomorphic to 'void', i.e, it
is a type that has an empty set of possible values.
choice types provide algebraic sum types of all the generic arguments
provided to choice. A instance of a choice type is a tagged union of
the types provided as actual generic type parameters. This concept is
also called variant, sum type or coproduct in other contexts.
Syntactic sugar of the Fuzion language permits an alternative notation
for choice types with actual generics as follows
A | B | C | ...
which is equivalent to
choice A B C ...
The parser will directly convert the first notation into a choice type
with actual generics.
A field of choice type can be assigned a value of the same choice type
or of any of the actual generic type arguments provided to the choice
feature.
Two choice types choice A B and choice B A that differ only in the order
of their actual generic arguments are treated as different types.
Named choice types can be constructed through inheritance, i.e.,
C : choice A B is {}
creates a choice type of A and B with the name C. Two named choice types
D and E that inherit from choice with the same actual generic arguments in
the same order are nevertheless different types and their values are not
assignable to one another.
Named choice types may declare or inherit additional inner features as long
as these features are not fields. Also, declared inner features must not
build a closure that accesses outer features. Additional parents must be
unit types, i.e., they must not declare fields nor access features of any
of their outer features.
Note that all types provided must be distinct, it is not possible to
repeat the same type as in choice i32 i32 or float | float. If a sum
type of two or more equal types is desired, these types must first be
wrapped into a new type as illustrated in the following example:
Say we want to store a temperature that is given as a 32 bit integer
in degrees centigrade or degrees Fahrenheit. So we define two wrapper
features
centigrade(degrees i32) is {}
fahrenheit(degrees i32) is {}
Now we define the choice type using the wrapped i32 types, which are
distinct:
hasFever(temp centigrade | fahrenheit) bool is ...
When passing arguments to this feature, we need to wrap them accordingly:
hasFever (centigrade 37)
hasFever (fahrenheit 99)
When matching the choice type, we use the wrapper types and access the
argument field 'degrees' to access the i32 stored inside
match temp
NYI: Once Fuzion's match statement supports destructuring as well, we should
be able to extract the degrees directly as in
match temp
A choice type with no actual generic arguments is isomorphic to 'void', i.e, it
is a type that has an empty set of possible values.
§complex(C type :numeric complex.C, real C, imag C) => complex complex.C:numeric complex complex.C,complexes complex.C
§complex(C
type
:numeric complex.C, real C, imag C) =>
complex complex.C:
numeric complex complex.C,complexes complex.Ccomplex -- complex numbers based on arbitrary numeric type
complex provides complex numbers based on a numeric type (e.g. f64, i32).
A complex number consists of a real and an imaginary part.
complex provides complex numbers based on a numeric type (e.g. f64, i32).
A complex number consists of a real and an imaginary part.
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).
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.
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
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
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.
conststring cannot be called directly, instances are created implicitly by the
backend.
initialize a new ctrie
ctrie -- routine to initialize a ctrie from a sequence of key value tuples
This feature creates an instance of a ctrie.
example: ctrie [(key1, value1), (key2, value2)]
This feature creates an instance of a ctrie.
example: ctrie [(key1, value1), (key2, value2)]
debug -- features related to debug setting
debug is a condition qualifier that enables conditions if debugging is
enabled.
this is true if and only if the debug level is greater than zero.
debug is a condition qualifier that enables conditions if debugging is
enabled.
this is true if and only if the debug level is greater than zero.
debug(i32) is a condition qualifier that enables conditions if debugging is
enabled at the given debug-level.
enabled at the given debug-level.
Current debug level, used by condition qualified debug(i32)
This can be controlled using the "-debug=" option to the fz tool:
Whatever option was set at compile time will be used when running a
compile program.
This can be controlled using the "-debug=" option to the fz tool:
Whatever option was set at compile time will be used when running a
compile program.
effect -- abstract parent feature for effects
effect provides a means to perform effectful operations. Instances
of effect are installed in the current environment while their code is
executed. The code may access the effect via <type>.env.
effect provides a means to perform effectful operations. Instances
of effect are installed in the current environment while their code is
executed. The code may access the effect via <type>.env.
effect mode is an enum that determines how an instance of effect is used
equals -- feature that compares two values using the equality relation
defined in their type
defined in their type
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
NYI: Future versions of error might be equipped with a stack trace if
debugging is enabled
install given exit handler and run code with it.
exit -- effect that terminates a computation in exit
exit with a code argument calls exit.exit code, i.e., it uses the
current exit efffect to exit with the given message.
current exit efffect to exit with the given message.
Exit_Handler -- abstract exit
type related to exit declaring features not requiring an instance of exit
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
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
instance
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
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
instance
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<<.
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.
float is the abstract parent of concrete floating point features such as
f32 or f64.
§float_sequence(F type :float float_sequence.F, from Sequence float_sequence.F) => float_sequence float_sequence.F:numeric_sequence float_sequence.F
§float_sequence(F
type
:float float_sequence.F, from Sequence float_sequence.F) =>
float_sequence float_sequence.F:
numeric_sequence float_sequence.Ffloat_sequence -- a Sequence whose elements inherit from float
floats -- unit type defining features related to float but not requiring
an instance
an instance
§fraction(B type :integer fraction.B, num B, den B) => fraction fraction.B:numeric fraction fraction.B
§fraction(B
type
:integer fraction.B, num B, den B) =>
fraction fraction.B:
numeric fraction fraction.Bfraction
fraction provides fraction numbers based on an integer type to represent the
numerator and the denominator.
basic numeric operations +, -, * and comparison are supported. numerator and
denominator are reduced after each operation.
there are currently no checks or preconditions for overflows in the numerator
or the denominator.
fraction provides fraction numbers based on an integer type to represent the
numerator and the denominator.
basic numeric operations +, -, * and comparison are supported. numerator and
denominator are reduced after each operation.
there are currently no checks or preconditions for overflows in the numerator
or the denominator.
Function -- generic function with arbitrary number of arguments and result
R is the result type of the function, A are the argument types of the function
R is the result type of the function, A are the argument types of the function
Functions -- unit type containing features related to functions but not requiring an instance
initializes a new handle with the given initial value
this uses the handles instance from the current environment
this uses the handles instance from the current environment
create a new handle2 using the handles2 instance from the current environment
short-hand for creating and installing an empty set of handles of given type.
short-hand for accessing handles monad for given type in current environment
short-hand for creating and installing an empty set of handles2 of given type.
short-hand for accessing handles monad for given type in current environment
short-hand for creating an empty set of handles2 of given type.
unit type containing features related to handles but nor requiring an instance
short-hand for creating an empty set of handles of given type.
unit type containing features related to handles but nor requiring an instance
has_equality -- feature for immutable values that define an equality relation
has_hash -- feature for immutable values that have a hash function
NYI: the compiler should check that features inheriting from this are
actually immutable.
NYI: the compiler should check that features inheriting from this are
actually immutable.
has_partial_order -- feature for immutable values that have an infix <=
predicate that defines a partial order
features inheriting from has_partial_order define a partial order of their
values
NYI: the compiler should check that features inheriting from this are
actually immutable.
predicate that defines a partial order
features inheriting from has_partial_order define a partial order of their
values
NYI: the compiler should check that features inheriting from this are
actually immutable.
has_total_order -- feature for immutable values that have an infix ≤ function
predicate that defines a total order
features inheriting from has_total_order define a total order of their values
NYI: the compiler should check that features inheriting from this are
actually immutable.
predicate that defines a total order
features inheriting from has_total_order define a total order of their values
NYI: the compiler should check that features inheriting from this are
actually immutable.
§hash_map(HK type, V type, ks array hash_map.HK, vs array hash_map.V) => hash_map hash_map.HK hash_map.V:Map hash_map.HK, hash_map.V
§hash_map(HK
type
, V type
, ks array hash_map.HK, vs array hash_map.V) =>
hash_map hash_map.HK hash_map.V:
Map hash_map.HK, hash_map.Vhash_map -- an immutable hash map from keys HK to values V
hasInterval -- feature for integers that can define an interval
i128 -- 128-bit signed integer values
i128 -- returns value of unit type i128s
This is a convenience feature that allows using, e.g., 'i128.sum' to
get the the monoid of (i128, infix +) instead of 'i128s.sum'.
since this i128 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with i128 with one
argument).
This is a convenience feature that allows using, e.g., 'i128.sum' to
get the the monoid of (i128, infix +) instead of 'i128s.sum'.
since this i128 with no arguments is a routine and not a constructor, it
does not define a type (which would cause a name clash with i128 with one
argument).
i128s -- unit type defining features related to i128 but not requiring an
instance
instance
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).
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).
i16 -- 16-bit signed integer values
i16s -- unit type defining features related to i16 but not requiring an
instance
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).
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).
i32 -- 32-bit signed integer values
i32s -- unit type defining features related to i32 but not requiring an
instance
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).
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).
i64 -- 64-bit signed integer values
i64s -- unit type defining features related to i64 but not requiring an
instance
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).
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).
i8 -- 8-bit signed integer values
i8s -- unit type defining features related to i8 but not requiring an
instance
instance
identity function
infix operator to create a list from head h and lazy tail t.
This is convenient to append an element before a list as in
0 : ()->[1,2,3,4].as_list
or to create lists by recursion, e.g., a an endless list containing
integer 1 repeatedly is
ones => 1 : ()->ones
This is convenient to append an element before a list as in
0 : ()->[1,2,3,4].as_list
or to create lists by recursion, e.g., a an endless list containing
integer 1 repeatedly is
ones => 1 : ()->ones
three-way comparison between this and other.
result is < 0 if this < other
result is > 0 if this > other
result is = 0 if this = other
result is < 0 if this < other
result is > 0 if this > other
result is = 0 if this = other
three-way comparison between this and other.
result is < 0 if this < other
result is > 0 if this > other
result is = 0 if this = other
result is < 0 if this < other
result is > 0 if this > other
result is = 0 if this = other
integer -- abstract ancestor of integer numbers
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.
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.
convenience routine to create a list from head h and lazy tail t.
NYI: #1166, syntax sugar for lazy evaluation
NYI: #1166, syntax sugar for lazy evaluation
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 an infinite 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.
A list is immutable, so it can be reused and shared between threads.
Compared to a stream, a list may require more (heap) allocation.
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 an infinite 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.
A list is immutable, so it can be reused and shared between threads.
Compared to a stream, a list may require more (heap) allocation.
convenience routine to create a list from head h and tail t.
NYI: #1166, syntax sugar for lazy evaluation
NYI: #1166, syntax sugar for lazy evaluation
lists -- unit type defining features related to list but not requiring an
instance
instance
lteq -- feature that compares two values using the lteq relation
defined in their type
defined in their type
Map -- an abstract map from keys K to values V
map_of -- routine to initialize a map from an array of key value tuples
This feature creates an instance of a map.
example: map_of [(key1, value1), (key2, value2)]
This feature creates an instance of a map.
example: map_of [(key1, value1), (key2, value2)]
map_of -- routine to initialize a map from arrays of ordered elements
and values
This feature creates an instance of a map.
and values
This feature creates an instance of a map.
§marray(T type, length i32, data fuzion.sys.internal_array marray.T) => marray marray.T:Sequence marray.T
§marray(T
type
, length i32, data fuzion.sys.internal_array marray.T) =>
marray marray.T:
Sequence marray.Tmarray -- one-dimensional mutable array
NYI: marray should be rewritten using effects.
NYI: marray should be rewritten using effects.
matrices -- unit type defining features related to matrix
matrices is a unit type defining features related to matrix but not
requiring an instance.
matrices is a unit type defining features related to matrix but not
requiring an instance.
§matrix(M type :numeric matrix.M, e array2 matrix.M) => matrix matrix.M:numeric matrix matrix.M,matrices matrix.M
§matrix(M
type
:numeric matrix.M, e array2 matrix.M) =>
matrix matrix.M:
numeric matrix matrix.M,matrices matrix.Mmatrix -- matrix based on arbitrary numeric type
matrix provides matrix operations based on an arbitray numeric type
matrix provides matrix operations based on an arbitray numeric type
negative sign of a number
note that this value is of unit type minus, not of type sign
note that this value is of unit type minus, not of type sign
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.
Don't be scared, in Java terms: A monad is a means to compose functions
applied to generic types.
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.
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.
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.
create a new mutable value of type T with initial value v
mutate -- an effect that permits creation and mutation of mutable values.
This effect is typically used to work with mutable values. You can create
a mutable value as follows
v := mutate.env.new i32 42
and then modify it using
v <- 666
To read it, call 'get' as in
say "v is {v.get}"
Convenience feature 'mut' and type inference allow the creation to be
written as
v := mut 42
NYI: syntax sugar to read mutable field using
w := v + 1
instead of
w := v.get + 1
is not supported yet.
This effect is typically used to work with mutable values. You can create
a mutable value as follows
v := mutate.env.new i32 42
and then modify it using
v <- 666
To read it, call 'get' as in
say "v is {v.get}"
Convenience feature 'mut' and type inference allow the creation to be
written as
v := mut 42
NYI: syntax sugar to read mutable field using
w := v + 1
instead of
w := v.get + 1
is not supported yet.
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.
This is a unit type that is preferred to represent instances that are
not present, e.g, in an option.
num_option with 1 argument provides an short-hand to wrap a value into a
num_option
Using this enables to write
o := num_option x
instead of
o num_option TypeOfX := x
num_option
Using this enables to write
o := num_option x
instead of
o num_option TypeOfX := x
§num_option(T type :numeric num_option.T) => void:choice num_option.T, nil,monad num_option.T, num_option num_option.T
§num_option(T
type
:numeric num_option.T) =>
void:
choice num_option.T, nil,monad num_option.T, num_option num_option.Tnum_option -- 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.
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.
§numeric(T type :numeric numeric.T) => numeric numeric.T:has_hash ,has_total_order ,numerics numeric.T
§numeric(T
type
:numeric numeric.T) =>
numeric numeric.T:
has_hash ,has_total_order ,numerics numeric.Tnumeric -- parent of all numeric features
§numeric_sequence(N type :numeric numeric_sequence.N, from Sequence numeric_sequence.N) => numeric_sequence numeric_sequence.N:searchable_sequence numeric_sequence.N,has_equality
§numeric_sequence(N
type
:numeric numeric_sequence.N, from Sequence numeric_sequence.N) =>
numeric_sequence numeric_sequence.N:
searchable_sequence numeric_sequence.N,has_equality numeric_sequence -- a Sequence whose elements inherit from numeric
numerics -- unit type defining features related to numeric but not
requiring an instance
requiring an instance
§oneway_monad(A type, OMA type :oneway_monad oneway_monad.A oneway_monad.OMA, r effectMode.val) => oneway_monad oneway_monad.A oneway_monad.OMA:monad oneway_monad.A, oneway_monad.OMA,effect
§oneway_monad(A
type
, OMA type
:oneway_monad oneway_monad.A oneway_monad.OMA, r effectMode.val) =>
oneway_monad oneway_monad.A oneway_monad.OMA:
monad oneway_monad.A, oneway_monad.OMA,effect oneway_monad -- heir feature of all one-way monads.
oneway_monad is the heir feature of all one-way monads. A one-way monad is
a monadic feature that can be accessed only throuh the environment and
that will be replaced in the environment whenever a new instance is created.
oneway_monad is the heir feature of all one-way monads. A one-way monad is
a monadic feature that can be accessed only throuh the environment and
that will be replaced in the environment whenever a new instance is created.
option with 1 argument provides an short-hand to wrap a value into an option
Using this enables to write
o := option x
insted of
o option TypeOfX := x
Using this enables to write
o := option x
insted of
o option TypeOfX := x
option -- feature wrapping a value or nothing
option represents an optional value of type T
option represents an optional value of type T
ordered_map -- an immutable map from ordered keys OK to values V
Lookup performance is O(log size) since it uses binary search in a
sorted array. When deterministic performance is desired, an ordered map
should be preferred over a hash map.
performance of creation of the map is in O(n log n) where n is
keys.length.
Lookup performance is O(log size) since it uses binary search in a
sorted array. When deterministic performance is desired, an ordered map
should be preferred over a hash map.
performance of creation of the map is in O(n log n) where n is
keys.length.
outcome with 1 argument provides an short-hand to wrap a value into a
outcome
Using this enables to write
o := outcome x
instead of
o outcome TypeOfX := x
outcome
Using this enables to write
o := outcome x
instead of
o outcome TypeOfX := x
outcome -- result type for functions that may return an error
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
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.
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
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.
panic -- effect that terminates a computation in panic
panic with no argument returns panic.env, the currently installed
panic provider.
panic provider.
panic with a msg argument calls panic.panic msg, i.e., it uses the
current panic efffect to panic with the given message.
current panic efffect to panic with the given message.
Panic_Provider -- abstract panic
type related to panic declaring features not requiring an instance of panic
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.
currently, pedantic always returns true.
pedantic is a condition qualifier for conditions a pedantic purist would require,
but that a more relaxed hacker would prefer to do without.
currently, pedantic always returns true.
positive sign of a number
note that this value is of unit type plus, not of type sign
note that this value is of unit type plus, not of type sign
§ps_map(PK type, V type, ks Sequence ps_map.PK, vs Sequence ps_map.V) => ps_map ps_map.PK ps_map.V:Any
§ps_map(PK
type
, V type
, ks Sequence ps_map.PK, vs Sequence ps_map.V) =>
ps_map ps_map.PK ps_map.V:
Any ps_map -- routine to initialize a partially sorted map from two Sequences
This feature creates a pre-initialized instance of ps_map.
This feature creates a pre-initialized instance of ps_map.
§ps_map(PK type, V type, data fuzion.sys.internal_array (tuple ps_map.PK ps_map.V), size i32, fill i32) => ps_map ps_map.PK ps_map.V:Map ps_map.PK, ps_map.V
§ps_map(PK
type
, V type
, data fuzion.sys.internal_array (tuple ps_map.PK ps_map.V), size i32, fill i32) =>
ps_map ps_map.PK ps_map.V:
Map ps_map.PK, ps_map.Vps_map -- a partially sorted map
ps_map is a persistent map from an ordered key PK to a value V. This map is
generally well-behaved with respect to cumulative and average performance.
The keys and values are stored in arrays consisting of sorted sub-arrays,
with sub-arrays corresponding to the 1-bits in the binary representation
of the size.
This results in cumulative memory usage in O(size log² size), worst-case
lookup time in O(log² size) and average addition time in O(1) and worst-case
addition time in O(size log² size).
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_map is performance critical. If the resulting map's size n is a
power of 2, this will trigger the worst-case addition time resutling in
O(m*n log² n) for adding an element m times.
This constructor is for internal use only, to create instance of ps_map, use
ps_map PK V without arguments.
ps_map is a persistent map from an ordered key PK to a value V. This map is
generally well-behaved with respect to cumulative and average performance.
The keys and values are stored in arrays consisting of sorted sub-arrays,
with sub-arrays corresponding to the 1-bits in the binary representation
of the size.
This results in cumulative memory usage in O(size log² size), worst-case
lookup time in O(log² size) and average addition time in O(1) and worst-case
addition time in O(size log² size).
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_map is performance critical. If the resulting map's size n is a
power of 2, this will trigger the worst-case addition time resutling in
O(m*n log² n) for adding an element m times.
This constructor is for internal use only, to create instance of ps_map, use
ps_map PK V without arguments.
ps_maps -- unit type feature declaring features related to ps_map
NYI: move to ps_map.type
NYI: move to ps_map.type
ps_set -- routine to initialize a partially sorted set from one Sequence
This feature creates a pre-initialized instance of ps_set.
This feature creates a pre-initialized instance of ps_set.
ps_set -- a partially sorted set based on ps_map
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resutling in
O(m*n log² n) for adding an element m times.
ps_set is a persistent set of ordered values. This set is generally
well-behaved with respect to cumulative and average performance.
WARNING: Due to the high worst-case time for addition, this structure should
not be used in situations when adding a single element repeatedly to the same
instance of ps_set is performance critical. If the resulting set's size n is a
power of 2, this will trigger the worst-case addition time resutling in
O(m*n log² n) for adding an element m times.
ps_sets -- unit type feature declaring features related to ps_set
NYI: move to ps_set.type
NYI: move to ps_set.type
quantors -- unit type feature containing quantors ∀ and ∃.
quantors provides forAll and exists-quantors for use in contracts qualified
for analysis.
quantors provides forAll and exists-quantors for use in contracts qualified
for analysis.
random -- effect that provides random numbers
random with no argument returns random.env, i.e., the currently installed
source of randomness.
source of randomness.
Random_Provider -- abstract source of random numbers
This provides the random number input to be used by the 'random' effect.
Implementation may be dumb sequences of pseudo-random numbers or high-qualiity
cryptographic random number generators
A Random_Provider contains an immutable state, repeated calls to 'get' result
in the same value. To produce a sequence of different random numbers, 'next'
must be used to create a new instance of 'Random_Provider' before 'get' can be
used to obtain the new random number.
This provides the random number input to be used by the 'random' effect.
Implementation may be dumb sequences of pseudo-random numbers or high-qualiity
cryptographic random number generators
A Random_Provider contains an immutable state, repeated calls to 'get' result
in the same value. To produce a sequence of different random numbers, 'next'
must be used to create a new instance of 'Random_Provider' before 'get' can be
used to obtain the new random number.
type related to random declaring features not requiring an instance of random
safety -- 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.
Currently, the value of this can be controlled by setting the fuzion.safety
Java property when calling the fz tool, for example like this:
If the program is compiled, not interpreted, then the value of this option
at compile time will be used.
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.
Currently, the value of this can be controlled by setting the fuzion.safety
Java property when calling the fz tool, for example like this:
If the program is compiled, not interpreted, then the value of this option
at compile time will be used.
say -- shortcut for io.out.println
A handy shortcut for io.out.println, output string representation of
an object followed by a line break.
A handy shortcut for io.out.println, output string representation of
an object followed by a line break.
searchable_list -- a list whose elements inherit from has_equality
In contrast to searchable_sequence, this uses choice type 'list' and not ref
type 'Sequence', so it is more efficient.
In contrast to searchable_sequence, this uses choice type 'list' and not ref
type 'Sequence', so it is more efficient.
searchable_sequence -- a Sequence whose elements inherit from has_equality
In contrast to searchable_list, this uses ref type 'Sequence' and not choice
type 'list', so it is more flexible.
In contrast to searchable_list, this uses ref type 'Sequence' and not choice
type 'list', so it is more flexible.
Sequence -- ancestor for features that can be converted to a 'list' or a
'stream'
Sequences are empty, finite or infinite ordered collections of instances
of a given type. Sequences may calculate elements lazily on demand.
Sequence is a 'ref' type, i.e., different sub-features may be assigned
to a field of type 'Sequence'.
Heirs of Sequence must implement either 'as_list' or 'as_stream'. Failure
to implement any of these results in an endless recursion when the Sequence
is used.
'stream'
Sequences are empty, finite or infinite ordered collections of instances
of a given type. Sequences may calculate elements lazily on demand.
Sequence is a 'ref' type, i.e., different sub-features may be assigned
to a field of type 'Sequence'.
Heirs of Sequence must implement either 'as_list' or 'as_stream'. Failure
to implement any of these results in an endless recursion when the Sequence
is used.
Sequences -- unit type defining features related to Sequence but not requiring
an instance
an instance
Set -- an abstract set of values V
set_of_hashable -- routine to initialize a set from a Sequence of hashable elements
This feature creates an instance of a Set.
This feature creates an instance of a Set.
set_of_ordered -- routine to initialize a set from a Sequence of ordered elements
This feature creates an instance of a Set.
This feature creates an instance of a Set.
the sign of a number
this can be plus or minus
this can be plus or minus
simple random number provider for pseudo random numbers that are not safe
for security and that do not meet typical requirements for a good
random number generator.
for security and that do not meet typical requirements for a good
random number generator.
type related to simple_random_provider declaring features not requiring an instance
of simple_random_provider
of simple_random_provider
simpleEffect provides a simple means to define and use an effect
user-defined effects should inherit from this feature and add
operations as inner features or fields of function type.
To install this effect to execute a function, simpleEffect.use
can be called.
user-defined effects should inherit from this feature and add
operations as inner features or fields of function type.
To install this effect to execute a function, simpleEffect.use
can be called.
some -- standard wrapper for values of type T
§sorted_array(T type, from Sequence sorted_array.T, less_or_equal Function bool sorted_array.T sorted_array.T) => sorted_array sorted_array.T:array sorted_array.T
§sorted_array(T
type
, from Sequence sorted_array.T, less_or_equal Function bool sorted_array.T sorted_array.T) =>
sorted_array sorted_array.T:
array sorted_array.Tsorted_array -- sorted one-dimensional immutable array
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed peformance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).
This takes an unsorted array and a compare function as an arguments and
returns a sorted one.
Non-mutating heap sort is used internally. This gives guaranteed peformance in
O(n log n) comparisons and assignments for an array of size n.
This is a little wasteful on allocated memory, which is also O(n log n) since
partially sorted arrays are thrown away. This might be improved to use an
in-place heap sort to bring allocated memory down to O(n).
sorted_array_of -- 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 sorted_array from less_or_equal for details
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 sorted_array from less_or_equal for details
spit -- shortcut for stdout.print
NYI: remove?
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.
NYI: remove?
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.
state with 1 argument is short hand for a state containing unit and
initialValue
initialValue
install new state monad for type S and run r within that state monad
return result of r.
return result of r.
§state(T type, S type, val T, get S, r effectMode.val) => state state.T state.S:oneway_monad state.T, state state.T state.S
§state(T
type
, S type
, val T, get S, r effectMode.val) =>
state state.T state.S:
oneway_monad state.T, state state.T state.Sstate -- represent a state using a monad
this can be used both as plain or as a oneway monad to store a state
in a way orthogonal to the actual computation.
this can be used both as plain or as a oneway monad to store a state
in a way orthogonal to the actual computation.
short-hand for getting state monad for given type in current environment
short-hand for modifying state monad for given type in current environment
short-hand for accessing state monad for given type in current environment
short-hand for setting state monad for given type in current environment
type related to state declaring features not requiring an instance of state
stdout -- shorthand for fuzion.sys.out
NYI: remove?
NYI: remove?
stream -- a stream of values
A stream contains mutable state, so it cannot be reused or shared
between threads.
The mutable nature of streams requires particular prudence, as even basic
actions, such as calling as_string on a stream will consume values and thus
change the state of the stream, as the following example demonstrates:
a := [1, 2, 3, 4, 5].as_stream
say a
say a
In this example, the first invocation of say will print "1, 2, 3, 4, 5",
the second invocation will print "".
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.
A stream contains mutable state, so it cannot be reused or shared
between threads.
The mutable nature of streams requires particular prudence, as even basic
actions, such as calling as_string on a stream will consume values and thus
change the state of the stream, as the following example demonstrates:
a := [1, 2, 3, 4, 5].as_stream
say a
say a
In this example, the first invocation of say will print "1, 2, 3, 4, 5",
the second invocation will print "".
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.
streams -- unit type defining features related
to streams but not requiring an instance
to streams but not requiring an instance
string -- immutable sequences of utf8 encoded unicode characters
sum -- generic sum of the elements of a Sequence of numeric.
This allows summing the elements of a list, as in
l := [1,2,3]
say (sum l) # '6'
This allows summing the elements of a list, as in
l := [1,2,3]
say (sum l) # '6'
sum0 -- generic sum of the elements of a Sequence of numeric with type parameter.
This allows summing the elements of a list, as in
l := [1,2,3]
say (sum0 i32 l) # '6'
NYI: When we move numerics.sum to numeric.type.sum, we should not need this any longer.
This allows summing the elements of a list, as in
l := [1,2,3]
say (sum0 i32 l) # '6'
NYI: When we move numerics.sum to numeric.type.sum, we should not need this any longer.
TA result type
B input type
C transduced type
B input type
C transduced type
transducers map one reducing function to another
see https://clojure.org/reference/transducers
for in depth information about transducers
usage example:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
see https://clojure.org/reference/transducers
for in depth information about transducers
usage example:
human(age i32) is
ages := map (Sequence i32) human i32 (x -> x.age)
gt_ten := filter (Sequence i32) i32 (x -> x > 10)
xf := ages ∘ gt_ten
say ([human(4), human(12), human(30)].into xf) # [12,30]
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<<.
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<<.
convenience routine to create a new instance of 'try' and run 'f' in
it.
it.
try -- simple exception effect
try provides an operation 'raise' that immediately stops execution and
returns an 'error' wrapped in an 'oucome'.
try provides an operation 'raise' that immediately stops execution and
returns an 'error' wrapped in an 'oucome'.
convenience routine to create a new instance of 'try' and run 'f' in
it. Return the result of 'f' directly or panic in case 'f' calls
'try.env.raise'.
it. Return the result of 'f' directly or panic in case 'f' calls
'try.env.raise'.
tuple -- feature used to define tuple types
tuple types provide algebraic product types of all the generic arguments
provided to tuple.
The values within a tuple 'tuple A B C' can be accessed via the tuple's
argument field 'values' followed by a selector referring to the generic
argument's position: 'values.0', 'values.1' and 'values.2', respectively.
Syntactic sugar of the Fuzion language permits an alternative notation
to create values of tuple types as follows
t := (a, b, c, ... )
is equivalent to
t := tuple a b c ...
The actual generic types are inferred from the static types of the values
'a', 'b', 'c', ... the tuple is created from.
Similarly, syntactic sugar for the destructuring of tuples can be used
to access the values as in
(a, b, c, ...) := t
In destructurings, we can denote values we are not interested in using
'_' as in
(_, b) := ("first", "second")
which will set 'b' to '"second"' and drop the first element of the tuple.
As an example, say we want to identify a person by its name and its age,
so we can define
a := ("Alice" , 11)
b := ("Bob" , 22)
c := ("Claire", 33)
Then, we could extract Bob's age using
(_, age) := b
or Claire's name using
(name, _) := c
Destructuring also works for general features, e.g.
point (x,y i32) is {}
p := point 3, 4
(px, py) := p # will set px to 3 and py to 4
and the destructured value can then be used to create a tuple
t := (px, py) # will create tuple<i32,i32> instance
however, tuples are not assignment compatible with general features even
if they would destructure into the same types, i.e.,
u tuple i32 i32 = p # will cause compile time error
q point = (7, 12) # will cause compile time error
The unit tuple '()' can be used as a short-hand to create the empty tuple
'tuple'. The empty tuple can be destructured like any other tuple
using
() := ()
even though this has no effect.
An instance of the single tuple 'tuple A' with sole element 'a' can not
be created using syntactic sugar '(a)', this will produce the plain
value of 'a' instead. However, destructuring of a single tuple is possible:
(a0) := tuple a
which is equivalent to
a0 := a
NYI: A single tuple 'tuple A' is currently not assignment compatible with
type 'A', which would make handling of general tuples easier.
tuples and destructuring can be used to swap two elements or create a
permutation as in
(a, b) := (b, a)
(o, t, a, n) := (n, a, t, o)
A tuple type with no actual generic arguments is isomorphic to 'unit', i.e, it
is a type that has only one single value: '()'.
tuple types provide algebraic product types of all the generic arguments
provided to tuple.
The values within a tuple 'tuple A B C' can be accessed via the tuple's
argument field 'values' followed by a selector referring to the generic
argument's position: 'values.0', 'values.1' and 'values.2', respectively.
Syntactic sugar of the Fuzion language permits an alternative notation
to create values of tuple types as follows
t := (a, b, c, ... )
is equivalent to
t := tuple a b c ...
The actual generic types are inferred from the static types of the values
'a', 'b', 'c', ... the tuple is created from.
Similarly, syntactic sugar for the destructuring of tuples can be used
to access the values as in
(a, b, c, ...) := t
In destructurings, we can denote values we are not interested in using
'_' as in
(_, b) := ("first", "second")
which will set 'b' to '"second"' and drop the first element of the tuple.
As an example, say we want to identify a person by its name and its age,
so we can define
a := ("Alice" , 11)
b := ("Bob" , 22)
c := ("Claire", 33)
Then, we could extract Bob's age using
(_, age) := b
or Claire's name using
(name, _) := c
Destructuring also works for general features, e.g.
point (x,y i32) is {}
p := point 3, 4
(px, py) := p # will set px to 3 and py to 4
and the destructured value can then be used to create a tuple
t := (px, py) # will create tuple<i32,i32> instance
however, tuples are not assignment compatible with general features even
if they would destructure into the same types, i.e.,
u tuple i32 i32 = p # will cause compile time error
q point = (7, 12) # will cause compile time error
The unit tuple '()' can be used as a short-hand to create the empty tuple
'tuple'. The empty tuple can be destructured like any other tuple
using
() := ()
even though this has no effect.
An instance of the single tuple 'tuple A' with sole element 'a' can not
be created using syntactic sugar '(a)', this will produce the plain
value of 'a' instead. However, destructuring of a single tuple is possible:
(a0) := tuple a
which is equivalent to
a0 := a
NYI: A single tuple 'tuple A' is currently not assignment compatible with
type 'A', which would make handling of general tuples easier.
tuples and destructuring can be used to swap two elements or create a
permutation as in
(a, b) := (b, a)
(o, t, a, n) := (n, a, t, o)
A tuple type with no actual generic arguments is isomorphic to 'unit', i.e, it
is a type that has only one single value: '()'.
Type -- parent feature of all type features
type features 'f.type' are declared implicitly for every feature f.
Type features do not contain state, they are unit types.
All type features inherit directly (Any.type) or indirectly (all
others type features) from this feature.
type features 'f.type' are declared implicitly for every feature f.
Type features do not contain state, they are unit types.
All type features inherit directly (Any.type) or indirectly (all
others type features) from this feature.
universe feature to determine the compile-time type of an expression.
This is to be called without an actual type passed to `T`, but `T` should be
inferred from the actual value argument `_`.
The value arugment is evaluated and ignored.
The result is the type of the value argument boxed into a ref value and returned
as a value of type `Type`.
examples:
`type_of "bla"` is `String`
`type_of (panic "***")` will terminate
This is to be called without an actual type passed to `T`, but `T` should be
inferred from the actual value argument `_`.
The value arugment is evaluated and ignored.
The result is the type of the value argument boxed into a ref value and returned
as a value of type `Type`.
examples:
`type_of "bla"` is `String`
`type_of (panic "***")` will terminate
universe feature to determine the compile-time type of an expression.
This is to be called without an actual type passed to `T`, but `T` should be
inferred from the result type of the actual value argument `_`.
The function passed as value arugment is ignored, it is not called.
The result is the result type of the value argument boxed into a ref value and
returned as a value of type `Type`.
examples:
`type_of_lazy ()->"bla"` is Type of `String`
`type_of_lazy ()->(panic "***")` is Type of `void`.
NYI: Fuzion should have better syntax sugar for lazy value arguments such that
we do not need the `()->` prefix to create a lambda. Then, `type_of` could
have a lazy argument and `type_of_lazy` could be removed.
This is to be called without an actual type passed to `T`, but `T` should be
inferred from the result type of the actual value argument `_`.
The function passed as value arugment is ignored, it is not called.
The result is the result type of the value argument boxed into a ref value and
returned as a value of type `Type`.
examples:
`type_of_lazy ()->"bla"` is Type of `String`
`type_of_lazy ()->(panic "***")` is Type of `void`.
NYI: Fuzion should have better syntax sugar for lazy value arguments such that
we do not need the `()->` prefix to create a lambda. Then, `type_of` could
have a lazy argument and `type_of_lazy` could be removed.
u128 -- 128-bit unsigned integer values
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).
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
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).
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).
u16 -- 16-bit unsigned integer values
u16s -- unit type defining features related to u16 but not requiring an
instance
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).
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).
u32 -- 32-bit unsigned integer values
u32s -- unit type defining features related to u32 but not requiring an
instance
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).
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).
u64 -- 64-bit unsigned integer values
u64s -- unit type defining features related to u64 but not requiring an
instance
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).
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).
u8 -- 8-bit unsigned integer values
u8s -- unit type defining features related to u8 but not requiring an
instance
instance
unsigned integer of arbitrary size, including zero
represented by its bit sequence
represented by its bit sequence
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
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
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 synonym 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 assigning a value of unit
type, so these are very efficient as well.
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
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
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 synonym 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 assigning 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 := 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 produces 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
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.
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 := 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 produces 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
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.
§wrapping_integer(W type :wrapping_integer wrapping_integer.W) => wrapping_integer wrapping_integer.W:integer wrapping_integer.W,wrapping_integers wrapping_integer.W
§wrapping_integer(W
type
:wrapping_integer wrapping_integer.W) =>
wrapping_integer wrapping_integer.W:
integer wrapping_integer.W,wrapping_integers wrapping_integer.Wwrapping_integer -- abstract ancestor of wrap-around integer numbers
wrapping_integer is the abstract ancestor of integer numbers that have min and
max values and operations with wrap-around semantics.
wrapping_integer is the abstract ancestor of integer numbers that have min and
max values and operations with wrap-around semantics.
§wrapping_integers(W type :wrapping_integer wrapping_integers.W) => wrapping_integers wrapping_integers.W:numerics wrapping_integers.W
§wrapping_integers(W
type
:wrapping_integer wrapping_integers.W) =>
wrapping_integers wrapping_integers.W:
numerics wrapping_integers.Wwrapping_integers -- unit type defining features related to wrapping_integer
but not requiring an instance
but not requiring an instance
contains the final value of a computation.
used e.g. in Sequence.reduce