In Hades, function declarations don't contain the return type of the functions. Neither do the datatypes of the input values have to be defined.
Statically typed parameters
A function which is defined with static types, can only be called with those lines. If a function definition for a function with the types specified in the function call does not exist, execution will fail. The return type of a function is declared with ->. If a function doesn't return anything: ->none (although technically a function never doesn't return anything, a fallback 0 is always returned but none warns you if you use the default 0). Only if a function is fully typed, it can be JITed.
Example
with console from std:io
func add(a int, b int) //can also be written as `func add(a b int)
console.out("Adds two ints")
put a + b
end
func add(a string, b string) -> string
console.out("Concatenates two strings")
put "{} {}".format(a,b)
end
add(2,2) //Output: Adds two ints
add("Hello","world") //Output: Concatenates two strings
add(1.5,1.5) //Execution fails
Dynamically-typed parameters
This function can be used with every datatype.
Example
with console from std:io
func add(a,b)
var result = a + b
console.out(result)
put result
end
add(2,2) //Output: 4
add("Hello ","world") //Output: Hello world
add(1.5,1.5) //Output: 3.0
Varargs
Varargs allow for method invocation with multiple parameters which are treated as a single parameter array by the function. A function can only have one vararg parameter.
Example
with console from std:io
func sum(...a int)
var result = 0
for(var i in a)
result += i
end
put result
end
func print(...a)
for(var arg in a)
console.out(arg)
end
end
func print(...a, times int)
for(var i in range(1,times))
for(var arg in a)
console.out(arg)
end
end
end
console.out(sum(1, 2, 3, 4, 5, 6, 7, 8, 9))
print("Hello", ",", "world")
print("Hello", "," ,"world", 5/*this is the 'times' parameter*/)
Function guards
With function guards, an initial condition has to be fulfilled for the function to be called. If the condition is not fulfilled, another function (ordered by declaration) with the same name and different, or no, function guard is called.
Example
with console from std:io
func myFunction(a int) requires a < 10
console.out("a is smaller than 10")
end
func myFunction(a int) -> none requires a is 11
console.out("a is 11")
end
func myFunction(a int) requires a > 11 and a < 21
console.out("a is greater than 11 and smaller than 21")
end
func myFunction(a int)
//This default function is called when every condition is false
console.out("a is " + a)
end
myFunction(1) //Output: a is smaller than 10
myFunction(11) //Output: a is 11
myFunction(15) //Output: a is greater than 11 and smaller than 21
myFunction(50) //Output: a is 50
Function guards by match
In addition to the normal function guards, Hades also offers function guards by object/list match. To use this feature, one must first define the function.
with console from std:io
func doSomething(person);
func doSomething(person := Employee{department: "IT"})
console.out("{} works in IT".format(person.firstname))
end
func doSomething(Employee{department: "Finance", firstname := firstname})
console.out("{} works in Finance".format(firstname))
end
doSomething(Employee("John", "Finance")) //Output: John works in Finance
doSomething(Employee("Steve", "IT")) //Output: Steve works in IT
with console from std:io
func getStatus(status);
func getStatus(status := :ok)
console.out("Everything went well")
end
func getStatus(:error)
console.out("An error occured")
end
func getStatus(status)
console.out("Unrecognized status code")
end
getStatus(:ok) //Output: Everything went well
getStatus(:foo) //Output: Unrecognized status code
with console from std:io
func onReceive(e);
func onReceive(e := {:ok, message})
console.out("Received {}".format(message))
end
func onReceive({:error, _})
console.out("Error while receiving message")
end
Custom blocks
Custom blocks are syntactic sugar that behave like lambdas but are written in do syntax.
Example
func forEach(arr *any[*], executor lambda::(any)->any)
put arr |> map(executor)
end
forEach({1, 2, 3}) do |x|
console.out(x)
end
var strings = forEach({1, 2, 3}) do |x|
put x.toString()
end
func doStuff(executor lambda::(none)->none)
executor()
end
doStuff do
console.out("Hello")
end
Nested functions
As with normal function declarations, nested functions can either explicitly name a type, or not:
Example
with math as m from std:math
func doMath(a int)
func root(b int)
put m.sqrt(b)
end
func square(b)
put b * b
end
put square(a) + root(a)
end
Access modifiers
Functions can have access modifiers. If they do, they follow the same rules as variables. See Non-local Variables.
Fixed function
Fixed functions are like static function in Java or C#. One can only declare fixed functions in classes, because in scripts or mixed files, every function which is outside a class is accessible.
Overriding functions
One can override functions (both built-in, as well as inherited) by appending ! to the func statement. Some internal functions are not overridable because of the way they're implemented. These functions are type, nameof, send and self.
Example
with assert from std:testing
class Car
...
func! toString() -> string
put "My custom string"
end
end
assert.equal(Car().toString(), "My custom string")
assert.equal("{}".format(Car()), "My custom string")
Default values
When a function that has default values is being used, the sequence of the parameters which don't have default values stays the same as an invocation without overriding these defaults.
Example
func functionWithDefaultValues(a,b=1,c,d="d",e,f=true)
...
end
functionWithDefaultValues(b=2, d="D", "This is 'a'", "This is 'c'", f=false, "This is 'e'")
