Rather than keep track of a tuple argument, we can destructure the tuple into function parameters.
func printPlanet(planet= [name, value]: [str, float]): void {
% ^ label for destructured parameter
planet; %> ReferenceError
"""The radius of {{ name }} is {{ value }}km.""";
}
% typeof printPlanet: (planet: [str, float]) => void
Notice the “pattern” in the brackets. The function still has one parameter, a tuple of type [str, float], but inside the function body we can treat each component as if it were a separate parameter. Notice also the parameter name planet, followed by the symbol = used for aliasing (#46). It’s not defined inside the function body, but the caller may still use it as the label of a named argument if they wish.
We can make our declaration a litle more consise by moving the typings inside the destructure pattern.
func printPlanet(planet= [name: str, value: float]): void {
% typeof name == str
% typeof value == float
;
}
Destructuring applies to unfixed parameters as well.
func printPlanet(planet= [unfixed name, value]: [str, float]): void {
set name = """Planet {{ name }}"""; % ok
set value = value + 1.0; %> AssignmentError
}
Above, we used tuple destructuring, that is, assigning the pattern [a, b] a tuple. We can also use record destructuring by assigning it a record. Instead of declaring a record parameter…
we can destructure the record into separate parameters:
func printPlanet(planet= [name$, value$]: [name: str, value: float]): void {
planet; %> ReferenceError
"""The radius of {{ name }} is {{ value }}km.""";
}
Or, with the “inside” type annotation, if you like:
func printPlanet(planet= [name$: str, value$: float]): void {
"""The radius of {{ name }} is {{ value }}km.""";
}
As with tuple destructuring, this doesn’t change the type signature of the function. It only allows the function body to reference each component of the pattern separately. Destructuring parameters is an implementation technique, which is why type aliases and abstract methods do not allow it.
Recall that with record destructuring for variables (#43), the symbol $ is shorthand for repeating the variable name — [x$] is shorthand for [x= x]. This is called “punning”. This holds for parameters as well. We can replace $ with internal parameter names.
func printPlanet(planet= [name= n: str, value= v: float]): void {
name; %> ReferenceError
value; %> ReferenceError
"""The radius of {{ n }} is {{ v }}km.""";
}
% typeof printPlanet: (planet: [name: str, value: float]) => void
The caller must supply a [name: str, value: float] argument, but the internal implementation of the function references the parameters n and v.
Again, we can declare unfixed parameters.
func f(numbers= [
w$: int,
xray= x: int,
y= unfixed y: int,
zulu= unfixed z: int,
]): void {
set w = 0; %> AssignmentError
set x = 0; %> AssignmentError
set y = 0; % ok
set z = 0; % ok
}
Optional Parameters
Optional destructured parameters work just like regular parameters; they must be initialized to a value assignable to the correct type.
func printPlanetNamed(planet= [name: str, value: float] ?= ["Earth", 6371.0]): void {
"""The radius of {{ name }} is {{ value }}km.""";
}
% typeof printPlanetNamed: (planet?: [str, float]) => void
We can also have optional record destructuring parameters:
func printPlanetNamed(planet= [name= n: str, value= v: float] ?= [name= "Earth", value= 6371.0]): void {
"""The radius of {{ n }} is {{ v }}km.""";
}
% typeof printPlanetNamed: (planet?: [name: str, value: float]) => void
Nested Destructuring
Like destructuring for variables, we can nest destructuing syntax for functions.
Destructuring parameters in function definitions.
Discussion
Function Parameter Declaration
Consider this function:
Rather than keep track of a tuple argument, we can destructure the tuple into function parameters.
Notice the “pattern” in the brackets. The function still has one parameter, a tuple of type
[str, float], but inside the function body we can treat each component as if it were a separate parameter. Notice also the parameter nameplanet, followed by the symbol=used for aliasing (#46). It’s not defined inside the function body, but the caller may still use it as the label of a named argument if they wish.We can make our declaration a litle more consise by moving the typings inside the destructure pattern.
Destructuring applies to unfixed parameters as well.
Above, we used tuple destructuring, that is, assigning the pattern [
a,b] a tuple. We can also use record destructuring by assigning it a record. Instead of declaring a record parameter…we can destructure the record into separate parameters:
Or, with the “inside” type annotation, if you like:
As with tuple destructuring, this doesn’t change the type signature of the function. It only allows the function body to reference each component of the pattern separately. Destructuring parameters is an implementation technique, which is why type aliases and abstract methods do not allow it.
Recall that with record destructuring for variables (#43), the symbol
$is shorthand for repeating the variable name —[x$]is shorthand for[x= x]. This is called “punning”. This holds for parameters as well. We can replace$with internal parameter names.The caller must supply a
[name: str, value: float]argument, but the internal implementation of the function references the parametersnandv.Again, we can declare unfixed parameters.
Optional Parameters
Optional destructured parameters work just like regular parameters; they must be initialized to a value assignable to the correct type.
We can also have optional record destructuring parameters:
Nested Destructuring
Like destructuring for variables, we can nest destructuing syntax for functions.
Specfication
Syntax Grammar