Learn Programming: Records (Structs)

class Person {
    constructor() {
        this.name = ""
        this.age = 0
        this.gender = ""
    }
}

// It is also possible to do:
// class Person {
//    name = ""
//    age = 0
//    gender = ""
//}

let franco = new Person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

console.log(franco)
console.log(franco.name)
console.log(franco.age)
console.log(franco.gender)

// The name could be Person() to become closer to other programming languages.
function new_person() {
    // JavaScript Object.
    return {
        "name": "",
        "age": 0,
        "gender": ""
    }
    // Or:
    // return {
    //     name: "",
    //     age: 0,
    //     gender: ""
    // }
}

let franco = new_person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

console.log(franco)
console.log(franco.name)
console.log(franco.age)
console.log(franco.gender)

class Person:
    def __init__(self):
        self.name = ""
        self.age = 0
        self.gender = ""

franco = Person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

print(franco)
print(franco.name)
print(franco.age)
print(franco.gender)

-- The name could be Person() to become closer to other programming languages.
function new_person()
    return {
        name = "",
        age = 0,
        gender = ""
    }
end

local franco = new_person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

print(franco)
print(franco.name)
print(franco.age)
print(franco.gender)

extends Node

# Inner class.
class Person:
    # If an initial value is omitted, it will be null.
    var name = ""
    var age = 0
    var gender = ""

    # An _init() method is optional (as a contructor).

func _ready():
    var franco = Person.new()
    franco.name = "Franco"
    franco.age = 1234
    franco.gender = "Male"

    print(franco)
    print(franco.name)
    print(franco.age)
    print(franco.gender)

extends Node

# File as class.
# The name of the file is the name of the class.
# It is also possible to define a custom name for the class using:
# class_name Person

# If an initial value is omitted, it will be null.
var name
var age
var gender

func _init():
    name = ""
    age = 0
    gender = ""

func _ready():
    name = "Franco"
    age = 1234
    gender = "Male"

    var franco = self
    printt(self, franco)
    printt(name, self.name, franco.name)
    printt(age, self.age, franco.age)
    printt(gender, self.gender, franco.gender)

class Person {
    constructor() {
        this.name = ""
        this.age = 0
        this.gender = ""
    }
}

function initialize_person(person) {
    person.name = "Franco"
    person.age = 1234
    person.gender = "Male"
}

let franco = new Person()
console.log(franco)
console.log(franco.name)
console.log(franco.age)
console.log(franco.gender)

initialize_person(franco)
console.log(franco)
console.log(franco.name)
console.log(franco.age)
console.log(franco.gender)

function new_person() {
    // JavaScript Object.
    return {
        "name": "",
        "age": 0,
        "gender": ""
    }
}

function initialize_person(person) {
    person.name = "Franco"
    person.age = 1234
    person.gender = "Male"
}

let franco = new_person()
console.log(franco)
console.log(franco.name)
console.log(franco.age)
console.log(franco.gender)

initialize_person(franco)
console.log(franco)
console.log(franco.name)
console.log(franco.age)
console.log(franco.gender)

class Person:
    def __init__(self):
        self.name = ""
        self.age = 0
        self.gender = ""

def initialize_person(person):
    person.name = "Franco"
    person.age = 1234
    person.gender = "Male"

franco = Person()
print(franco)
print(franco.name)
print(franco.age)
print(franco.gender)

initialize_person(franco)
print(franco)
print(franco.name)
print(franco.age)
print(franco.gender)

function new_person()
    return {
        name = "",
        age = 0,
        gender = ""
    }
end

function initialize_person(person)
    person.name = "Franco"
    person.age = 1234
    person.gender = "Male"
end

local franco = new_person()
print(franco)
print(franco.name)
print(franco.age)
print(franco.gender)

initialize_person(franco)
print(franco)
print(franco.name)
print(franco.age)
print(franco.gender)

extends Node

class Person:
    var name
    var age
    var gender

func initialize_person(person):
    person.name = "Franco"
    person.age = 1234
    person.gender = "Male"

func _ready():
    var franco = Person.new()
    print(franco)
    print(franco.name)
    print(franco.age)
    print(franco.gender)

    initialize_person(franco)
    print(franco)
    print(franco.name)
    print(franco.age)
    print(franco.gender)

extends Node

var name
var age
var gender

func _init():
    name = ""
    age = 0
    gender = ""

func initialize_person():
    name = "Franco"
    age = 1234
    gender = "Male"

func initialize_person_com_parametro(person):
    person.name = "Franco Garcia"
    person.age = 4321
    person.gender = "MASCULINO"

func _ready():
    print(self)
    printt(name, self.name)
    printt(age, self.age)
    printt(gender, self.gender)

    # The call will affect the object itself.
    # In this case, the modification of values is a side effect of the call.
    initialize_person()
    print(self)
    printt(name, self.name)
    printt(age, self.age)
    printt(gender, self.gender)

    # The previous code is equivalent to the use of self as a parameter.
    initialize_person_com_parametro(self)
    print(self)
    printt(name, self.name)
    printt(age, self.age)
    printt(gender, self.gender)

class Person {
    constructor() {
        this.name = ""
        this.age = 0
        this.gender = ""
    }
}

function equal_people(person1, person2) {
    return ((person1.name === person2.name) &&
            (person1.age === person2.age) &&
            (person1.gender === person2.gender))
}

function different_people(person1, person2) {
    return (!equal_people(person1, person2))
}

let person1 = new Person()
let person2 = new Person()
console.log(person1 === person2, equal_people(person1, person2))
console.log(person1 !== person2, different_people(person1, person2))

function new_person() {
    // JavaScript Object.
    return {
        "name": "",
        "age": 0,
        "gender": ""
    }
}

function equal_people(person1, person2) {
    return ((person1.name === person2.name) &&
            (person1.age === person2.age) &&
            (person1.gender === person2.gender))
}

function different_people(person1, person2) {
    return (!equal_people(person1, person2))
}

let person1 = new_person()
let person2 = new_person()
console.log(person1 === person2, equal_people(person1, person2))
console.log(person1 !== person2, different_people(person1, person2))

class Person:
    def __init__(self):
        self.name = ""
        self.age = 0
        self.gender = ""

def equal_people(person1, person2):
    return ((person1.name == person2.name) and
            (person1.age == person2.age) and
            (person1.gender == person2.gender))

def different_people(person1, person2):
    return (not equal_people(person1, person2))

person1 = Person()
person2 = Person()
print(person1 == person2, equal_people(person1, person2))
print(person1 != person2, different_people(person1, person2))

function new_person()
    return {
        name = "",
        age = 0,
        gender = ""
    }
end

function equal_people(person1, person2)
    return ((person1.name == person2.name) and
            (person1.age == person2.age) and
            (person1.gender == person2.gender))
end

function different_people(person1, person2)
    return (not equal_people(person1, person2))
end

local person1 = new_person()
local person2 = new_person()
print(person1 == person2, equal_people(person1, person2))
print(person1 ~= person2, different_people(person1, person2))

extends Node

class Person:
    var name
    var age
    var gender

func equal_people(person1, person2):
    return ((person1.name == person2.name) and
            (person1.age == person2.age) and
            (person1.gender == person2.gender))

func different_people(person1, person2):
    return (not equal_people(person1, person2))

func _ready():
    var person1 = Person.new()
    var person2 = Person.new()
    printt(person1 == person2, equal_people(person1, person2))
    printt(person1 != person2, different_people(person1, person2))

extends Node

class_name Person

var name
var age
var gender

func _init():
    name = ""
    age = 0
    gender = ""

func equal_people(person):
    return ((self.name == person.name) and
            (self.age == person.age) and
            (self.gender == person.gender))

func different_people(person):
    return (not equal_people(person))

func _ready():
    var person2 = get_script().new()
    printt(self == person2, equal_people(person2))
    printt(self != person2, different_people(person2))

    # It is not possible to use class_name for this case.
    # var person3 = Person.new()
    # printt(self == person3, equal_people(person3))
    # printt(self != person3, different_people(person3))

class Person:
    def __init__(self):
        self.name = ""
        self.age = 0
        self.gender = ""

    # It is important noticing the indentation.
    # The subroutine (method) is defined inside the class, in the same level of
    # __init__().
    def __eq__(self, person):
        if (type(self) != type(person)):
            return false

        return ((self.name == person.name) and
                (self.age == person.age) and
                (self.gender == person.gender))

    def __nq__(self, person):
        return (not self == person)

person1 = Person()
person2 = Person()
print(person1 == person2)
print(person1 != person2)

function equal_people(person1, person2)
    if (type(person1) ~= type(person2)) then
        return nil
    end

    return ((person1.name == person2.name) and
            (person1.age == person2.age) and
            (person1.gender == person2.gender))
end

function new_person()
    local data = {
        name = "",
        age = 0,
        gender = ""
    }
    local metatable = {
        __eq = equal_people
    }

    local person = setmetatable(data, metatable)

    return person
end

local person1 = new_person()
local person2 = new_person()
print(person1 == person2)
print(person1 ~= person2)

class Person {
    constructor() {
        this.name = ""
        this.age = 0
        this.gender = ""
    }

    toString() {
        let result = this.name + " (" + this.age + " years old, gender " + this.gender + ")"

        return result
    }
}

let franco = new Person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

console.log(franco)
console.log("" + franco)

let text = "Hello, " + franco + "!"
console.log(text)

function Person() {
    this.name = ""
    this.age = 0
    this.gender = ""
}

Person.prototype.toString = function() {
    let result = this.name + " (" + this.age + " years old, gender " + this.gender + ")"

    return result
}

let franco = new Person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

console.log(franco)
console.log("" + franco)

let text = "Hello, " + franco + "!"
console.log(text)

class Person:
    def __init__(self):
        self.name = ""
        self.age = 0
        self.gender = ""

    def __str__(self):
        result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

        return result

    def __eq__(self, person):
        if (type(self) != type(person)):
            return false

        return ((self.name == person.name) and
                (self.age == person.age) and
                (self.gender == person.gender))

    def __nq__(self, person):
        return (not self == person)

franco = Person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

print(franco)

text = "Hello, " + str(franco) + "!"
print(text)

function equal_people(person1, person2)
    if (type(person1) ~= type(person2)) then
        return nil
    end

    return ((person1.name == person2.name) and
            (person1.age == person2.age) and
            (person1.gender == person2.gender))
end

function person_to_string(person)
    local result = person.name .. " (" .. person.age .. " years old, gender " .. person.gender .. ")"

    return result
end

function concatenate(x, y)
    local result = tostring(x) .. tostring(y)
    return result
end

local person_metatable = {
    __eq = equal_people,
    __tostring = person_to_string,
    __concat = concatenate
}

function new_person()
    local data = {
        name = "",
        age = 0,
        gender = ""
    }

    local person = setmetatable(data, person_metatable)

    return person
end

local franco = new_person()
franco.name = "Franco"
franco.age = 1234
franco.gender = "Male"

print(franco)
print(tostring(franco))
print("" .. franco)

text = "Hello, " .. franco .. "!"
print(text)

extends Node

class Person:
    var name
    var age
    var gender

    func _to_string():
        var result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

        return result

func _ready():
    var franco = Person.new()
    franco.name = "Franco"
    franco.age = 1234
    franco.gender = "Male"

    print(franco)

    var text = "Hello, " + str(franco) + "!"
    print(text)

extends Node

var name
var age
var gender

func _init():
    name = ""
    age = 0
    gender = ""

func _ready():
    name = "Franco"
    age = 1234
    gender = "Male"

    var franco = self
    printt(self, franco)

    var text = "Hello, " + str(franco) + "!"
    print(text)

    text = "Hello, " + str(self) + "!"
    print(text)

func _to_string():
    var result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

    return result

class Person {
    constructor(name = "", age = 0, gender = "") {
        this.name = name
        this.age = age
        this.gender = gender
    }

    toString() {
        let result = this.name + " (" + this.age + " years old, gender " + this.gender + ")"

        return result
    }
}

let franco = new Person("Franco", 1234, "Male")
console.log(franco)
console.log("" + franco)

let text = "Hello, " + franco + "!"
console.log(text)

function Person(name = "", age = 0, gender = "") {
    this.name = name
    this.age = age
    this.gender = gender
}

Person.prototype.toString = function() {
    let result = this.name + " (" + this.age + " years old, gender " + this.gender + ")"

    return result
}

let franco = new Person("Franco", 1234, "Male")
console.log(franco)
console.log("" + franco)

let text = "Hello, " + franco + "!"
console.log(text)

class Person:
    def __init__(self, name = "", age = 0, gender = ""):
        self.name = name
        self.age = age
        self.gender = gender

    def __str__(self):
        result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

        return result

    def __eq__(self, person):
        if (type(self) != type(person)):
            return false

        return ((self.name == person.name) and
                (self.age == person.age) and
                (self.gender == person.gender))

    def __nq__(self, person):
        return (not self == person)

franco = Person("Franco", 1234, "Male")
print(franco)

text = "Hello, " + str(franco) + "!"
print(text)

function equal_people(person1, person2)
    if (type(person1) ~= type(person2)) then
        return nil
    end

    return ((person1.name == person2.name) and
            (person1.age == person2.age) and
            (person1.gender == person2.gender))
end

function person_to_string(person)
    local result = person.name .. " (" .. person.age .. " years old, gender " .. person.gender .. ")"

    return result
end

function concatenate(x, y)
    local result = tostring(x) .. tostring(y)
    return result
end

local person_metatable = {
    __eq = equal_people,
    __tostring = person_to_string,
    __concat = concatenate
}

function new_person(name, age, gender)
    local data = {
        name = name or "",
        age = age or 0,
        gender = gender or ""
    }

    local person = setmetatable(data, person_metatable)

    return person
end

local franco = new_person("Franco", 1234, "Male")
print(franco)
print(tostring(franco))
print("" .. franco)

text = "Hello, " .. franco .. "!"
print(text)

extends Node

class Person:
    var name
    var age
    var gender

    func _init(name = "", age = 0, gender = ""):
        self.name = name
        self.age = age
        self.gender = gender

    func _to_string():
        var result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

        return result

func _ready():
    var franco = Person.new("Franco", 1234, "Male")
    print(franco)

    var text = "Hello, " + str(franco) + "!"
    print(text)

extends Node

var name
var age
var gender

func _init(name = "", age = 0, gender = ""):
    self.name = name
    self.age = age
    self.gender = gender

func _ready():
    name = "Franco"
    age = 1234
    gender = "Male"

    var franco = self
    printt(self, franco)

    var text = "Hello, " + str(franco) + "!"
    print(text)

    text = "Hello, " + str(self) + "!"
    print(text)

func _to_string():
    var result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

    return result

class Person {
    constructor({name, age, gender} = {name: "", age: 0, gender: ""}) {
        // If name is undefined or null, initialized with the default value.
        this.name = (name) ? name : ""
        this.age = (age) ? age : 0
        this.gender = (gender) ? gender : ""
    }

    toString() {
        let result = this.name + " (" + this.age + " years old, gender " + this.gender + ")"

        return result
    }
}

let franco = new Person({
    name: "Franco",
    age: 1234,
    gender: "Male"
})
console.log(franco)
console.log("" + franco)

let text = "Hello, " + franco + "!"
console.log(text)

function Person({name, age, gender} = {name: "", age: 0, gender: ""}) {
    // If name is undefined or null, initialized with the default value.
    this.name = (name) ? name : ""
    this.age = (age) ? age : 0
    this.gender = (gender) ? gender : ""
}

Person.prototype.toString = function() {
    let result = this.name + " (" + this.age + " years old, gender " + this.gender + ")"

    return result
}

let franco = new Person({
    name: "Franco",
    age: 1234,
    gender: "Male"
})
console.log(franco)
console.log("" + franco)

let text = "Hello, " + franco + "!"
console.log(text)

function equal_people(person1, person2)
    if (type(person1) ~= type(person2)) then
        return nil
    end

    return ((person1.name == person2.name) and
            (person1.age == person2.age) and
            (person1.gender == person2.gender))
end

function person_to_string(person)
    local result = person.name .. " (" .. person.age .. " years old, gender " .. person.gender .. ")"

    return result
end

function concatenate(x, y)
    local result = tostring(x) .. tostring(y)
    return result
end

local person_metatable = {
    __eq = equal_people,
    __tostring = person_to_string,
    __concat = concatenate
}

function new_person(data)
    data = data or {}
    local data_person = {
        name = data.name or "",
        age = data.age or 0,
        gender = data.gender or ""
    }

    local person = setmetatable(data_person, person_metatable)

    return person
end

local franco = new_person({
    name = "Franco",
    age = 1234,
    gender = "Male"
})
print(franco)
print(tostring(franco))
print("" .. franco)

text = "Hello, " .. franco .. "!"
print(text)

extends Node

class Person:
    var name
    var age
    var gender

    func _init(data = {}):
        self.name = data.get("name", "")
        self.age = data.get("age", 0)
        self.gender = data.get("gender", "")

    func _to_string():
        var result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

        return result

func _ready():
    var franco = Person.new({
        name = "Franco",
        age = 1234,
        gender = "Male"
    })
    print(franco)

    var text = "Hello, " + str(franco) + "!"
    print(text)

extends Node

var name
var age
var gender

func _init(data = {}):
    self.name = data.get("name", "")
    self.age = data.get("age", 0)
    self.gender = data.get("gender", "")

func _ready():
    _init({
        name = "Franco",
        age = 1234,
        gender = "Male"
    })

    var franco = self
    printt(self, franco)

    var text = "Hello, " + str(franco) + "!"
    print(text)

    text = "Hello, " + str(self) + "!"
    print(text)

func _to_string():
    var result = self.name + " (" + str(self.age) + " years old, gender " + self.gender + ")"

    return result

const MINIMUM_CIVIL_AGE_OF_MAJORITY = 18

class Person {
    constructor(name = "", age = 0, gender = "") {
        this.name = name
        this.age = age
        this.gender = gender
    }

    has_civil_majority() {
        return (this.age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)
    }
}

let franco = new Person("Franco", 1234, "Male")
console.log(franco.has_civil_majority())

const MINIMUM_CIVIL_AGE_OF_MAJORITY = 18

function has_civil_majority(person) {
    if (!person.age) {
        return undefined
    }

    return (person.age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)
}

function new_person(name = "", age = 0, gender = "") {
    return {
        "name": name,
        "age": age,
        "gender": gender,
        "has_civil_majority": has_civil_majority
    }
}

let franco = new_person("Franco", 1234, "Male")
console.log(franco.has_civil_majority(franco))

from typing import Final

MINIMUM_CIVIL_AGE_OF_MAJORITY: Final = 18

class Person:
    def __init__(self, name = "", age = 0, gender = ""):
        self.name = name
        self.age = age
        self.gender = gender

    def has_civil_majority(self):
        return (self.age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)

franco = Person("Franco", 1234, "Male")
print(franco.has_civil_majority())

local MINIMUM_CIVIL_AGE_OF_MAJORITY <const> = 18

function has_civil_majority(person)
    if (person.age == nil) then
        return false
    end

    return (person.age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)
end

function new_person(name, age, gender)
    local person = {
        name = name or "",
        age = age or 0,
        gender = gender or "",
        -- Key               Function reference
        has_civil_majority = has_civil_majority
    }

    return person
end

local franco = new_person("Franco", 1234, "Male")
print(franco.has_civil_majority(franco))
-- The operator : pass the variable itself as the first parameter to the called method.
print(franco:has_civil_majority())

extends Node

const MINIMUM_CIVIL_AGE_OF_MAJORITY = 18

class Person:
    var name
    var age
    var gender

    func _init(name = "", age = 0, gender = ""):
        self.name = name
        self.age = age
        self.gender = gender

    func has_civil_majority():
        # Or return (self.age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)
        return (age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)

func _ready():
    var franco = Person.new("Franco", 1234, "Male")
    print(franco.has_civil_majority())

extends Node

const MINIMUM_CIVIL_AGE_OF_MAJORITY = 18

var name
var age
var gender

func _init(name = "", age = 0, gender = ""):
    self.name = name
    self.age = age
    self.gender = gender

func _ready():
    name = "Franco"
    age = 1234
    gender = "Male"

    var franco = self
    printt(self, franco)
    printt(has_civil_majority(), franco.has_civil_majority())

func has_civil_majority():
    # Ou: return (self.age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)
    return (age >= MINIMUM_CIVIL_AGE_OF_MAJORITY)

class ProgrammingLanguage {
    constructor(name = "", extension = "", example = "") {
        this.name = name
        this.extension = extension
        this.example = example
    }
}

let languages = [
    new ProgrammingLanguage("JavaScript", ".js", "console.log(\"Hello, my name is Franco!\")"),
    new ProgrammingLanguage("Python", ".py", "print(\"Hello, my name is Franco!\")"),
    new ProgrammingLanguage("Lua", ".lua", "print(\"Hello, my name is Franco!\")"),
    new ProgrammingLanguage("GDScript", ".gd", "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"),
]

for (let language of languages) {
    console.log("Programming Language: " + language.name)
    console.log("Extension: " + language.extension)
    console.log("Example:")
    console.log(language.example)
    console.log("---")
}

class ProgrammingLanguage:
    def __init__(self, name = "", extension = "", example = ""):
        self.name = name
        self.extension = extension
        self.example = example

languages = [
    ProgrammingLanguage("JavaScript", ".js", "console.log(\"Hello, my name is Franco!\")"),
    ProgrammingLanguage("Python", ".py", "print(\"Hello, my name is Franco!\")"),
    ProgrammingLanguage("Lua", ".lua", "print(\"Hello, my name is Franco!\")"),
    ProgrammingLanguage("GDScript", ".gd", "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"),
]

for language in languages:
    print("Programming Language: " + language.name)
    print("Extension: " + language.extension)
    print("Example:")
    print(language.example)
    print("---")

function new_programming_language(name, extension, example)
    local result = {
        name = name or "",
        extension = extension or "",
        example = example or ""
    }

    return result
end

local languages = {
    new_programming_language("JavaScript", ".js", "console.log(\"Hello, my name is Franco!\")"),
    new_programming_language("Python", ".py", "print(\"Hello, my name is Franco!\")"),
    new_programming_language("Lua", ".lua", "print(\"Hello, my name is Franco!\")"),
    new_programming_language("GDScript", ".gd", "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"),
}

for _, language in ipairs(languages) do
    print("Programming Language: " .. language.name)
    print("Extension: " .. language.extension)
    print("Example:")
    print(language.example)
    print("---")
end

extends Node

class ProgrammingLanguage:
    var name
    var extension
    var example

    func _init(name = "", extension = "", example = ""):
        self.name = name
        self.extension = extension
        self.example = example

func _ready():
    var languages = [
        ProgrammingLanguage.new("JavaScript", ".js", "console.log(\"Hello, my name is Franco!\")"),
        ProgrammingLanguage.new("Python", ".py", "print(\"Hello, my name is Franco!\")"),
        ProgrammingLanguage.new("Lua", ".lua", "print(\"Hello, my name is Franco!\")"),
        ProgrammingLanguage.new("GDScript", ".gd", "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"),
    ]

    for language in languages:
        print("Programming Language: " + language.name)
        print("Extension: " + language.extension)
        print("Example:")
        print(language.example)
        print("---")

class ProgrammingLanguages {
    constructor(names = [], extensions = [], examples = []) {
        this.names = names
        this.extensions = extensions
        this.examples = examples
    }
}

let languages = new ProgrammingLanguages(
    ["JavaScript", "Python", "Lua", "GDScript"],
    [".js", ".py", ".lua", ".gd"],
    [
        "console.log(\"Hello, my name is Franco!\")",
        "print(\"Hello, my name is Franco!\")",
        "print(\"Hello, my name is Franco!\")",
        "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"
    ]
)

for (let language_index in languages.names) {
    console.log("Programming Language: " + languages.names[language_index])
    console.log("Extension: " + languages.extensions[language_index])
    console.log("Example:")
    console.log(languages.examples[language_index])
    console.log("---")
}

class ProgrammingLanguages:
    def __init__(self, names = "", extensions = "", examples = ""):
        self.names = names
        self.extensions = extensions
        self.examples = examples

languages = ProgrammingLanguages(
    ["JavaScript", "Python", "Lua", "GDScript"],
    [".js", ".py", ".lua", ".gd"],
    [
        "console.log(\"Hello, my name is Franco!\")",
        "print(\"Hello, my name is Franco!\")",
        "print(\"Hello, my name is Franco!\")",
        "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"
    ]
)

for language_index in range(len(languages.names)):
    print("Programming Language: " + languages.names[language_index])
    print("Extension: " + languages.extensions[language_index])
    print("Example:")
    print(languages.examples[language_index])
    print("---")

function new_programming_languages(names, extensions, examples)
    local result = {
        names = names or {},
        extensions = extensions or {},
        examples = examples or {}
    }

    return result
end

local languages = new_programming_languages(
    {"JavaScript", "Python", "Lua", "GDScript"},
    {".js", ".py", ".lua", ".gd"},
    {
        "console.log(\"Hello, my name is Franco!\")",
        "print(\"Hello, my name is Franco!\")",
        "print(\"Hello, my name is Franco!\")",
        "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"
    }
)

for language_index = 1, #languages.names do
    print("Programming Language: " .. languages.names[language_index])
    print("Extension: " .. languages.extensions[language_index])
    print("Example:")
    print(languages.examples[language_index])
    print("---")
end

extends Node

class ProgrammingLanguages:
    var names
    var extensions
    var examples

    func _init(names = "", extensions = "", examples = ""):
        self.names = names
        self.extensions = extensions
        self.examples = examples

func _ready():
    var languages = ProgrammingLanguages.new(
        ["JavaScript", "Python", "Lua", "GDScript"],
        [".js", ".py", ".lua", ".gd"],
        [
            "console.log(\"Hello, my name is Franco!\")",
            "print(\"Hello, my name is Franco!\")",
            "print(\"Hello, my name is Franco!\")",
            "extends Node\nfunc _ready():\n    print(\"Hello, my name is Franco!\")"
        ]
    )

    for language_index in range(len(languages.names)):
        print("Programming Language: " + languages.names[language_index])
        print("Extension: " + languages.extensions[language_index])
        print("Example:")
        print(languages.examples[language_index])
        print("---")

class Ingredient {
    constructor(name = "", quantity = 0.0, measure_unit = "") {
        this.name = name
        this.quantity = quantity
        this.measure_unit = measure_unit
    }
}

class Recipe {
    constructor(name = "", preparation_steps = "", ingredients = []) {
        this.name = name
        this.preparation_steps = preparation_steps
        this.ingredients = ingredients
    }
}

let water = new Ingredient("Water", 3.0, "Cups")
let flour = new Ingredient("Flour", 4.0, "Cups")
let salt = new Ingredient("Salt", 2.0, "Tablespoons")
let yeast = new Ingredient("Yeast", 2.0, "Teaspoons")

let bread = new Recipe("Bread")
bread.ingredients.push(water)
bread.ingredients.push(flour)
bread.ingredients.push(salt)
bread.ingredients.push(yeast)
bread.preparation_steps = "..."

console.log(bread.name)
console.log("Ingredients:")
for (let ingredient of bread.ingredients) {
    console.log("- " + ingredient.name + ": " + ingredient.quantity + " " + ingredient.measure_unit)
}

console.log("Preparation steps:")
console.log(bread.preparation_steps)

class Ingredient:
    def __init__(self, name = "", quantity = 0.0, measure_unit = ""):
        self.name = name
        self.quantity = quantity
        self.measure_unit = measure_unit

class Recipe:
    def __init__(self, name = "", preparation_steps = "", ingredients = None):
        self.name = name
        self.preparation_steps = preparation_steps
        self.ingredients = ingredients if (ingredients != None) else []

water = Ingredient("Water", 3.0, "Cups")
flour = Ingredient("Flour", 4.0, "Cups")
salt = Ingredient("Salt", 2.0, "Tablespoons")
yeast = Ingredient("Yeast", 2.0, "Teaspoons")

bread = Recipe("Bread")
bread.ingredients.append(water)
bread.ingredients.append(flour)
bread.ingredients.append(salt)
bread.ingredients.append(yeast)
bread.preparation_steps = "..."

print(bread.name)
print("Ingredients:")
for ingredient in bread.ingredients:
    print("- " + ingredient.name + ": " + str(ingredient.quantity) + " " + ingredient.measure_unit)

print("Preparation steps:")
print(bread.preparation_steps)

function new_ingredient(name, quantity, measure_unit)
    local result = {
        name = name or "",
        quantity = quantity or 0.0,
        measure_unit = measure_unit or ""
    }

    return result
end

function new_recipe(name, preparation_steps, ingredients)
    local result = {
        name = name or "",
        preparation_steps = quantity or "",
        ingredients = ingredients or {}
    }

    return result
end

local water = new_ingredient("Water", 3.0, "Cups")
local flour = new_ingredient("Flour", 4.0, "Cups")
local salt = new_ingredient("Salt", 2.0, "Tablespoons")
local yeast = new_ingredient("Yeast", 2.0, "Teaspoons")

local bread = new_recipe("Bread")
table.insert(bread.ingredients, water)
table.insert(bread.ingredients, flour)
table.insert(bread.ingredients, salt)
table.insert(bread.ingredients, yeast)
bread.preparation_steps = "..."

print(bread.name)
print("Ingredients:")
for _, ingredient in ipairs(bread.ingredients) do
    print("- " .. ingredient.name .. ": " .. ingredient.quantity .. " " .. ingredient.measure_unit)
end

print("Preparation steps:")
print(bread.preparation_steps)

extends Node

class Ingredient:
    var name
    var quantity
    var measure_unit

    func _init(name = "", quantity = 0.0, measure_unit = ""):
        self.name = name
        self.quantity = quantity
        self.measure_unit = measure_unit

class Recipe:
    var name
    var preparation_steps
    var ingredients

    func _init(name = "", preparation_steps = "", ingredients = []):
        self.name = name
        self.preparation_steps = preparation_steps
        self.ingredients = ingredients

func _ready():
    var water = Ingredient.new("Water", 3.0, "Cups")
    var flour = Ingredient.new("Flour", 4.0, "Cups")
    var salt = Ingredient.new("Salt", 2.0, "Tablespoons")
    var yeast = Ingredient.new("Yeast", 2.0, "Teaspoons")

    var bread = Recipe.new("Bread")
    bread.ingredients.append(water)
    bread.ingredients.append(flour)
    bread.ingredients.append(salt)
    bread.ingredients.append(yeast)
    bread.preparation_steps = "..."

    print(bread.name)
    print("Ingredients:")
    for ingredient in bread.ingredients:
        print("- " + ingredient.name + ": " + str(ingredient.quantity) + " " + ingredient.measure_unit)

    print("Preparation steps:")
    print(bread.preparation_steps)

class ListItem {
    constructor(value, next = null) {
        this.value = value
        this.next = next}
}

let numbers = new ListItem(1,
                           new ListItem(2,
                                        new ListItem(3)))
let list_item = numbers
while (list_item !== null) {
    console.log(list_item.value)
    list_item = list_item.next
}

class ListItem:
    def __init__(self, value, next = None):
        self.value = value
        self.next = next

numbers = ListItem(1,
                   ListItem(2,
                            ListItem(3)))
list_item = numbers
while (list_item != None):
    print(list_item.value)
    list_item = list_item.next

function new_list_item(value, next)
    local result = {
        value = value,
        next = next or nil
    }

    return result
end

local numbers = new_list_item(1,
                              new_list_item(2,
                                            new_list_item(3)))
local list_item = numbers
while (list_item ~= nil) do
    print(list_item.value)
    list_item = list_item.next
end

extends Node

class ListItem:
    var value
    var next

    func _init(value, next = null):
        self.value = value
        self.next = next

func _ready():
    var numbers = ListItem.new(1,
                               ListItem.new(2,
                                            ListItem.new(3)))
    var list_item = numbers
    while (list_item != null):
        print(list_item.value)
        list_item = list_item.next

class Elevator {
    constructor(starting_floor = 0, minimum_floor = 0, maximum_floor = 5) {
        let maximum = minimum_floor
        let minimum = minimum_floor
        if (minimum_floor > maximum_floor) {
            minimum = maximum_floor
        } else {
            maximum = maximum_floor
        }

        let initial = starting_floor
        if (starting_floor < minimum) {
            initial = minimum
        } else if (starting_floor > maximum) {
            initial = maximum
        }

        this.minimum_floor = minimum
        this.maximum_floor = maximum
        this.current_floor = initial
    }
}

function set_floor(elevator, new_floor) {
    if ((new_floor >= elevator.minimum_floor) && (new_floor <= elevator.maximum_floor)) {
        elevator.current_floor = new_floor
    }
}

function go_up_one_floor(elevator) {
    set_floor(elevator, elevator.current_floor + 1)
}

function go_down_one_floor(elevator) {
    set_floor(elevator, elevator.current_floor - 1)
}

function random_integer(minimum_inclusive, maximum_inclusive) {
    let minimum = Math.ceil(minimum_inclusive)
    let maximum = Math.floor(maximum_inclusive)

    return Math.floor(minimum + Math.random() * (maximum + 1 - minimum))
}

let elevator = new Elevator(0, 0, 5)
for (i = 0; i < 10; ++i) {
    let starting_floor = elevator.current_floor
    console.log("The elevator is on the " + starting_floor + "º floor")

    if (random_integer(0, 1) === 0) {
        console.log("Next command: go down")
        go_down_one_floor(elevator)
    } else {
        console.log("Next command: go up")
        go_up_one_floor(elevator)
    }

    let floor_final = elevator.current_floor
    if (starting_floor !== floor_final) {
        console.log("Vruuum!")
    } else {
        console.log("... Nothing happens.")
    }
}
console.log("The elevator is on the " + elevator.current_floor + "º floor")

import random

class Elevator:
    def __init__(self, starting_floor = 0, minimum_floor = 0, maximum_floor = 5):
        maximum = minimum_floor
        minimum = minimum_floor
        if (minimum_floor > maximum_floor):
            minimum = maximum_floor
        else:
            maximum = maximum_floor

        initial = starting_floor
        if (starting_floor < minimum):
            initial = minimum
        elif (starting_floor > maximum):
            initial = maximum

        self.minimum_floor = minimum
        self.maximum_floor = maximum
        self.current_floor = initial

def set_floor(elevator, new_floor):
    if ((new_floor >= elevator.minimum_floor) and (new_floor <= elevator.maximum_floor)):
        elevator.current_floor = new_floor

def go_up_one_floor(elevator):
    set_floor(elevator, elevator.current_floor + 1)

def go_down_one_floor(elevator):
    set_floor(elevator, elevator.current_floor - 1)

random.seed()
elevator = Elevator(0, 0, 5)
for i in range(10):
    starting_floor = elevator.current_floor
    print("The elevator is on the " + str(starting_floor) + "º floor")

    if (random.randint(0, 1) == 0):
        print("Next command: go down")
        go_down_one_floor(elevator)
    else:
        print("Next command: go up")
        go_up_one_floor(elevator)

    floor_final = elevator.current_floor
    if (starting_floor != floor_final):
        print("Vruuum!")
    else:
        print("... Nothing happens.")

print("The elevator is on the " + str(elevator.current_floor) + "º floor")

function new_elevator(starting_floor, minimum_floor, maximum_floor)
    starting_floor = starting_floor or 0
    minimum_floor = minimum_floor or 0
    maximum_floor = maximum_floor or 0

    local maximum = minimum_floor
    local minimum = minimum_floor
    if (minimum_floor > maximum_floor) then
        minimum = maximum_floor
    else
        maximum = maximum_floor
    end

    local initial = starting_floor
    if (starting_floor < minimum) then
        initial = minimum
    elseif (starting_floor > maximum) then
        initial = maximum
    end

    local result = {
        minimum_floor = minimum,
        maximum_floor = maximum,
        current_floor = initial
    }

    return result
end

function set_floor(elevator, new_floor)
    if ((new_floor >= elevator.minimum_floor) and (new_floor <= elevator.maximum_floor)) then
        elevator.current_floor = new_floor
    end
end

function go_up_one_floor(elevator)
    set_floor(elevator, elevator.current_floor + 1)
end

function go_down_one_floor(elevator)
    set_floor(elevator, elevator.current_floor - 1)
end

math.randomseed(os.time())
local elevator = new_elevator(0, 0, 5)
for i = 1, 10 do
    local starting_floor = elevator.current_floor
    print("The elevator is on the " .. starting_floor .. "º floor")

    if (math.random(0, 1) == 0) then
        print("Next command: go down")
        go_down_one_floor(elevator)
    else
        print("Next command: go up")
        go_up_one_floor(elevator)
    end

    local floor_final = elevator.current_floor
    if (starting_floor ~= floor_final) then
        print("Vruuum!")
    else
        print("... Nothing happens.")
    end
end

print("The elevator is on the " .. elevator.current_floor .. "º floor")

extends Node

class Elevator:
    var current_floor
    var minimum_floor
    var maximum_floor

    func _init(starting_floor = 0, minimum_floor = 0, maximum_floor = 5):
        var maximum = minimum_floor
        var minimum = minimum_floor
        if (minimum_floor > maximum_floor):
            minimum = maximum_floor
        else:
            maximum = maximum_floor

        var initial = starting_floor
        if (starting_floor < minimum):
            initial = minimum
        elif (starting_floor > maximum):
            initial = maximum

        self.minimum_floor = minimum
        self.maximum_floor = maximum
        self.current_floor = initial

func set_floor(elevator, new_floor):
    if ((new_floor >= elevator.minimum_floor) and (new_floor <= elevator.maximum_floor)):
        elevator.current_floor = new_floor

func go_up_one_floor(elevator):
    set_floor(elevator, elevator.current_floor + 1)

func go_down_one_floor(elevator):
    set_floor(elevator, elevator.current_floor - 1)

func random_integer(minimum_inclusive, maximum_inclusive):
    var minimum = ceil(minimum_inclusive)
    var maximum = floor(maximum_inclusive)

    # randi(): [0.0, 1.0[
    return randi() % int(maximum + 1 - minimum) + minimum

func _ready():
    randomize()
    var elevator = Elevator.new(0, 0, 5)
    for i in range(10):
        var starting_floor = elevator.current_floor
        print("The elevator is on the " + str(starting_floor) + "º floor")

        if (random_integer(0, 1) == 0):
            print("Next command: go down")
            go_down_one_floor(elevator)
        else:
            print("Next command: go up")
            go_up_one_floor(elevator)

        var floor_final = elevator.current_floor
        if (starting_floor != floor_final):
            print("Vruuum!")
        else:
            print("... Nothing happens.")

    print("The elevator is on the " + str(elevator.current_floor) + "º floor")