chharvey
commented
2 months ago Semantics Discussion
Keyword void Must Be Isolated
Continued from #96. The keyword void is not a type and cannot be treated as types in the type system. It may only be used in return signatures of functions that execute completely but that do not return a value. It may not be combined with types. Functions can only return a type, or return void, but not a combination.
function return_void(): void { % ok
print.("hello");
return;
}
function return_int_or_void(): int | void %> SyntaxError
=> 42;
type VoidFn = () => void; % ok
type VoidOrIntFn = () => int | void; %> SyntaxError
class abstract Foo {
public doSomething(): void; % ok
public callVoidFn(void_fn: () => void): void { % ok
return void_fn.();
}
}Void Function Returns
Void function bodies are now required to have an explicit return; statement in every code path. This cannot be enforced syntactically, because it requires control flow analysis.
function maybe_return_void(): void {
print.("hello");
return; % <- required statement
}
function return_void(): void {
print.("hello");
return; % <- required statement
}
function conditionally_return_void(b: bool): void {
if b then {
print.(b);
return; % <- required statement
} else {
print.("""not {{ !b }}""");
return; % <- required statement
};
}
function no_else_branch(b: bool): void {
if b then {
print.(b);
};
return; % <- also valid
}
function invalid_no_else_branch(b: bool): void {
if b then {
print.(b);
return;
};
%> SemanticError: Expected a `return` statment in all code paths.
}Void Function Calls
Disallow assignment of void function calls in most cases.
function return_void(): void {
print.("hello");
return;
}
let val: unknown = return_void.(); %> AssignmentError
function take_unknown(arg: unknown): 0 {
arg;
return 0;
}
take_unknown.(return_void.()); %> AssignmentError
function return_unknown(): unknown {
return return_void.(); %> AssignmentError
}
let tup: [unknown] = [return_void.()]; %> AssignmentError
let tup_opt: [?: unknown] = [return_void.()]; %> AssignmentErrorThere is one exception: A void function call may be returned from another void function. This allows us to utilize tail calls.
function print_hello(): void {
return print.("hello"); % tail call allowed here
}
function print_world(): void
=> print.("world"); % implicit returns also allowedThe code above is valid, but only because the return signatures of the calling function and the called function are both void. If either function had a different return signature, we could not use the tail call.
With tail call optimization, the stack frame of the calling function may be reused to execute the called function. If returning void function calls were not allowed, we could not utilize this optimization.
function countdown(n: int): void {
if n > 0 then {
print.(n);
countdown.(n - 1);
return;
} else {
print.("Blast off!");
return;
};
}The code above is valid, but not optimal. Because this particular function is recursive, a tail call return countdown.(n - 1); would optimize the call stack and improve performance significantly.
Tail calls also allow us to write more functional-style code. Void functions should not be treated any differently from non-void functions.
% signature of `List<T>#forEach`: `(List.<T>; callback: (T) => void) => void`
List.<int>(my_ints).forEach.((i) => print.(i));
% is better than:
List.<int>(my_ints).forEach.((i) {
print.(i);
return;
});
Define synchronous function declarations and function expressions.
Discussion
Function Definitions
This issue covers defining void synchronous functions only, which do return but do not return a value (#70). This issue does not cover non-void functions, asynchronous functions, or error throwing.
This is a function declaration:
The name of this function is
add. It has two input parametersaandb, each of typeint. When a function is called (see v0.7.0), the values sent into the function are arguments. This function’s return type isvoid, because it has no output value. Its body is the set of statements within the curly braces.This is a function expression (lambda):
Lambdas are normal expressions that can be operated on and passed around like any other value. For instance, lambdas can be assigned to variables. Lambdas are always “truthy”.
Some parameters may be declared
unfixed, which means they can be reassigned within the function body.Type Signatures
A function’s type signature is its type, written in the form of
(‹params›) => ‹return›. It indicates what types of arguments are accepted and what type the function returns. This issue only covers functions that returnvoid.Function Assignment
When assigning a function to a type signature with named parameters (in the case of type alias assignment or abstract method implementation), the assigned parameter order must match up with the assignee parameters.
The reason for this error is that one should expect to be able to call any
BinaryOperatorTypewith the positional arguments of anintfollowed by afloat. Calling it with e.g.4.0and2, in that order, should fail. From this perspective, function assignment is a bit like tuple assignment.From another perspective, function assignment is like record assignment: the parameter names of the assigned must match the parameter names of the assignee.
This errors because a caller must be able to call
subtractwith the named argumentsfirstandsecond.Luckily, function parameter syntax has a built-in mechanism for handling function assignment/implementation with named parameters. In the parameter name, use
first= xto alias the real parameterxto the assignee parameterfirst.This lets the function author internally use the parameter names
xandywhile still allowing the caller to call the function with named argumentsfirstandsecondrepectively.Variance
Function parameter types are contravariant. This means that when assigning a function
gto a function typeF, the type of each parameter ofFmust be assignable to the corresponding parameter’s type ofg.A type error is raised because we cannot assign a
(float) => voidtype to a(float | str) => voidtype. Even though the parameter’s type is narrower, a caller should expect to be able to call anyUnaryOperatorimplementation with astrargument, and our implementation doesn’t allow that.However, we can widen the parameter types:
This meets the requirements of
UnaryOperatorbut still has a wider type for its parameter.Specification
Lexicon
Syntax
Semantics
Decorate
FunctionTypeOf