☰
outcome
outcome
Functions
returns o if outcome is ok, otherwise return the outcome's own
error.
error.
convert this outcome to an option
if the outcome is an error, the option is empty
if the outcome is an error, the option is empty
converts outcome to a string
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
returns the result of T.as_string for a successful outcome, or
"--$e--" for e error.
monadic operator
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
This enables a very idiomatic way of error handling: assume you are trying
to read 42 bytes from a file into a string. Let open be a feature that takes
a file name and returns an outcome of some abstract file descriptor, let read
be a feature that takes an abstract file descriptor and a number of bytes to
read and returns an outcome of a byte (u8) array. We want to read 42 bytes
from a file called "example.txt" into a string, and we wrap this into an outcome,
for handling the case that an error occurs when opening the file (i.e. it does
not exist) or when reading the file (i.e. example.txt is not actually a file but
a directory). Using match expressions, this is very cumbersome:
The monadic operator turns this into:
Get the dynamic type of this instance. For value instances `x`, this is
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierachy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
equal to `type_of x`, but for `x` with a `ref` type `x.dynamic_type` gives
the actual runtime type, while `type_of x` results in the static
compile-time type.
There is no dynamic type of a type instance since this would result in an
endless hierachy of types. So for Type values, dynamic_type is redefined
to just return Type.type.
error of an outcome that is known to contain an error
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
This can only be called in cases where it is known for sure that this
outcome is an error. A runtime error will be created otherwise.
monadic operator
§(B type, MB type, f Unary (monad.infix >>=~.MB) monad.A):Any => monad.infix >>=~.MB [Inherited from monad]
§(B
type
, MB type
, f Unary (monad.infix >>=~.MB) monad.A):
Any =>
monad.infix >>=~.MB [Inherited from monad]
monadic operator to another monad
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
Apply f to elements of type A and wrap them in MB.
NYI: This is currently useless since a redefinition is not
allowed for features with generic arguments. Is there a way
we could allow this anyway?
join operator
NYI: useless since redefinition currently not supported for
feature with generics.
NYI: useless since redefinition currently not supported for
feature with generics.
name of this type, including type parameters, e.g. 'option (list i32)'.
returns o if outcome is not ok, otherwise return this outcome's value.
short-hand postfix operator for 'is_error'
short-hand postfix operator for 'ok'
convenience prefix operator to create a string from a value.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
This permits usage of `$` as a prefix operator in a similar way both
inside and outside of constant strings: $x and "$x" will produce the
same string.
value of an outcome that is known to contain a value
This can only be called in cases where it is known for sure that this
outcomee is not an error. A runtime error will be created otherwise.
This can only be called in cases where it is known for sure that this
outcomee is not an error. A runtime error will be created otherwise.
Type Features
Get a type as a value.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
This is a feature with the effect equivalent to Fuzion's `expr.type` call tail.
It is recommended to use `expr.type` and not `expr.type_value`.
`type_value` is here to show how this can be implemented and to illustrate the
difference to `dynamic_type`.
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.
get_data (u User, t Type) outcome data IO_Error Permission_Error is
read_file t Type outcome data IO_Error is
Note that 'outcome data IO_Error' is not assignment compatible with
'outcome data IO_Error Permission_Error', 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 'read_file': This unwraps
'outcome data IO_Error' into 'IO_Error', which would be returned abruptly,
and 'data', which would be returned normally. Both are assignment
compatible to 'outcome data IO_Error Permission_Error', so everything
is fine.