Declaring functions

Declaring a function

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'")