with console from std:io
console->out("Hello world")

func add(a,b)
    put a + b
end

func add(int a, int b)
    put a + b
end

with console from std:io
​
func sum(args int a)
    var result = 0
​
    for(var i in a)
        result += i
    end
​
    put result
end
​
func print(args a)
    for(var arg in a)
        console->out(arg)
    end
end
​
func print(args a, int times)
    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*/)

with console from std:io
​
func myFunction(int a) requires a < 10
    console->out("a is smaller than 10")
end
​
func myFunction(int a) requires a is 11
    console->out("a is 11")
end
​
func myFunction(int a) requires a > 11 and a < 21
    console->out("a is greater than 11 and smaller than 21")
end
​
func myFunction(int a)
    //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

with math as m from std:math
​
func doMath(int a)
    func root(int b)
        put m->sqrt(b)
    end
​
    func square(b)
        put b * b
    end
​
    put square(a) + root(a)
end

let string a = "Hello, World!" //Immediate assignment
let b = "What's up?" //Type 'string' is inferred
let string c //Type 'string' is given, but variable is not assigned
let d //Type is inferred on first usage

var string a = "Hello, World!" //Immediate assignment
var b = "What's up?" //Type 'string' is inferred
var string c //Type 'string' is given, but variable is not assigned
var d //Type is inferred on first usage
var* e //Dynamic variable; can be anything, type can change

protected //Accessible from all inherited members
public  //Accessible over direct access
private //Not accessible from outside

object[] var EMPLOYEES
​
class employee
    public let string firstname = "John"
    public let lastname = "Doe"
    private var int age = 18
    var string[] attributes //When no access modifier is given, the variable will have private access
end

//A simple end-of-line comment
​
/*
*A lot of text is best written
*into a block comment.
*/

with console from std:io
​
if(a < 10)
    console->out("a is smaller than 10")
else if(a is 11)
    console->out("a is 11")
else if(a > 11 and a < 21)
    console->out("a is greater than 11 and smaller than 21")
else
    console->out("a is " + a)
end

with math fixed from std:math
with console from std:io
​
for(var int i in range(0,10) /*'range' returns an array with the number 0 to 10*/)
    console->out(i)
end
​
let string[] fruits = {"Apple", "Banana", "Mango", "Kiwi"}
​
for(var fruit in fruits)
    console->out("{} is very healthy"->format(fruit))
end

with console from std:io
var c = 0
​
while(c not 10)
    console->out("c is {}"->format(c))
    c++
end

with params from std:params
with exceptions from std:exceptions
with str from std:string
with Int from std:int
​
var a = params->get(0)
var b = params->get(1)
​
a :: raise exceptions->ArgumentNullException("{} is null"->format(nameof(a)))
b :: raise exceptions->ArgumentNullException("{} is null"->format(nameof(b)))
​
var number = a < b ? b : a
var numberFromString = Int->parse(value="This is not an integer", raise=false)
//one could also use int("This is not an integer")
var numberFromStringNullchecked = numberFromString :: 0

with console from std:io
​
let fruit = "Apple"
var lambda action = { _ => 
    console->print("Variable is of type string")
}
​
match(fruit)
    "Apple" => { _ => console->out("Apples are really tasty!")}
    fruit->type() is "string" => action
end
​
/*
Output: 
Apples are really tasty!
Variable is of type string
*/
​
match first(fruit)
    "Apple" => { _ => console->out("Apples are really tasty!")}
    fruit->type() is "string" => action
end
​
//Output: Apples are really tasty!

with client from mssql:client
with console from std:io
​
var object connection = client("Data Source=ServerName;Initial Catalog=DatabaseName;User ID=UserName;Password=Password")
​
try
    connection->open()
    console->out("Connection open!")
    connection->close()
catch(object::SqlException e)
    console->out("SqlException was caught!")
catch(e)
    console->out("An unknown exception was caught!")
end

with Calculator as calc from calc //loads from calc.hd
​
var calculator = calc() //no new keyword in Hades; instead the proto 'calc' is called

with list fixed from std:collections
with console from std:io
​
var fruits = list->of({"Apple", "Banana", "Mango", "Kiwi", "Avocado"})
​
fruits
|> map({x => x->toLower()}, ??)
|> filter({x => x->startsWith("a")}, ??)
|> forEach({x => console->out(x)}, ??)
​
//As opposed to
​
forEach({x => console->out(x)}, filter({x => x->startsWith("a")}, map({x => x->toLower()}, fruits)))
//map(lambda, list), filter(lambda, list) and forEach(lambda, list) are static methods from the list class
​
//Or even
​
fruits->map({x => x->toLower()})->filter({x => x->startsWith("a")})->forEach({x => console->out(x)})
//map(lambda), filter(lambda) and forEach(lambda) are methods from the list class

with console from std:io
​
class Vector
    var x = 0
    var y = 0
    var z = 0
    
    func Vector(x,y,z)
        this->x = x
        this->y = y
        this->z = z
    end
    
    func! toString()
        put "{},{},{}"->format(x,y,z)
    end
    
    func! op+(v)
        if(v is int)
            put Vector(x+v,y+v,z+v)
        else if(v is Vector)
            put Vector(x + v->x, y + v->y, z + v->z)
        end
        
        put null
    end
end
​
var v1 = Vector(1,2,3)
var v2 = Vector(4,5,6)
​
var v3 = v1 + v2 //overloaded operator is called
console->out(v3) //outputs: 5,7,9

with params from std:params
​
var address = params->getString(0)
var port = params->getInt(1)
var deamon = params->getBoolByName("d","deamon")
​
/*
so the execution call could look like:
hades server.hd localhost 8080 -d true
*/