Functions in Soplang

// Basic function definition
howl greet() {
    qor("Hello, World!")
}

// Calling the function
greet()  // Outputs: "Hello, World!"

// Good function names
howl calculateSum(a, b) {
    soo_celi a + b
}

howl getFirstName(names) {
    soo_celi names[0]
}

howl addData(data, section) {
    section.kudar(data)
}

// Function with parameters
howl greet(name) {
    qor("Hello, " + name + "!")
}

// Calling with arguments
greet("Farah")  // Outputs: "Hello, Farah!"
greet("Halima")  // Outputs: "Hello, Halima!"

// Function with multiple parameters
howl add(num1, num2, num3) {
    soo_celi num1 + num2 + num3
}

door result = add(10, 20, 30)
qor(result)  // Outputs: 60

// Function with default parameter values
howl calculateTax(amount, taxPercent = 15) {
    door tax = (taxPercent / 100) * amount
    soo_celi tax
}

qor(calculateTax(1000))  // Uses default 15%, Outputs: 150
qor(calculateTax(1000, 10))  // Uses provided 10%, Outputs: 100

// Function definition
howl createArticle(title, author, date, description = "") {
    // Function body
    soo_celi {
        "title": title,
        "author": author,
        "date": date,
        "description": description
    }
}

// Using named arguments
door article = createArticle(
    title = "Learning Soplang",
    author = "Farah",
    date = "2023-10-24",
    description = "A great new language"
)

// You can change the order with named arguments
door anotherArticle = createArticle(
    author = "Halima",
    description = "Making programming easier to learn", 
    date = "2023-10-20",
    title = "Soplang and Its Benefits"
)

// Function with variable number of arguments
howl addAll(...numbers) {
    door total = 0
    ku_celi num ku dhex jira numbers {
        total += num
    }
    soo_celi total
}

qor(addAll(1, 2, 3))  // Outputs: 6
qor(addAll(10, 20, 30, 40, 50))  // Outputs: 150
qor(addAll())  // Outputs: 0

// Function returning a value
howl square(num) {
    soo_celi num * num
}

door result = square(5)
qor(result)  // Outputs: 25

// Function with no explicit return
howl printMessage(message) {
    qor("LOG: " + message)
    // No return statement, implicitly returns waxba (null)
}

door output = printMessage("Hello")
qor(output)  // Outputs: null

// Early return example
howl getDivision(a, b) {
    haddii (b == 0) {
        qor("Error: Cannot divide by zero")
        soo_celi waxba
    }
    
    soo_celi a / b
}

qor(getDivision(10, 2))  // Outputs: 5
qor(getDivision(10, 0))  // Outputs: "Error: Cannot divide by zero" and then null

// Returning multiple values using a tuple
howl getNameParts(fullName) {
    door parts = fullName.split(" ")
    soo_celi [parts[0], parts.length > 1 ? parts[1] : ""]
}

door [firstName, lastName] = getNameParts("John Smith")
qor(firstName)  // Outputs: "John"
qor(lastName)   // Outputs: "Smith"

// Returning multiple values using an object
howl getPersonStats(person) {
    soo_celi {
        "age": person.age,
        "height": person.height,
        "weight": person.weight
    }
}

door person = { "name": "Sarah", "age": 28, "height": 165, "weight": 60 }
door stats = getPersonStats(person)
qor(stats.age)     // Outputs: 28
qor(stats.height)  // Outputs: 165

// Function scope example
howl calculateArea(width, height) {
    door area = width * height  // Local variable
    soo_celi area
}

door rectArea = calculateArea(5, 10)
qor(rectArea)  // Outputs: 50

// This would cause an error:
// qor(area)  // Error: 'area' is not defined

// Variables with the same name don't conflict
door area = "This is a global area variable"
door functionArea = calculateArea(3, 4)  // This uses its own local 'area'
qor(area)  // Outputs: "This is a global area variable"
qor(functionArea)  // Outputs: 12

// Closure example
howl createCounter(startValue = 0) {
    door count = startValue
    
    // Return a function that has access to the 'count' variable
    howl increment() {
        count += 1
        soo_celi count
    }
    
    soo_celi increment
}

door counter1 = createCounter(10)
door counter2 = createCounter(5)

qor(counter1())  // Outputs: 11
qor(counter1())  // Outputs: 12
qor(counter2())  // Outputs: 6
qor(counter1())  // Outputs: 13 - counter1 maintained its own state
qor(counter2())  // Outputs: 7 - counter2 maintained its own state

// Anonymous function assigned to a variable
door greet = howl(name) {
    soo_celi "Hello, " + name + "!"
}

qor(greet("John"))  // Outputs: "Hello, John!"

// Anonymous function as an argument
door numbers = [1, 2, 3, 4, 5]
door squaredNumbers = numbers.map(howl(num) {
    soo_celi num * num
})

qor(squaredNumbers)  // Outputs: [1, 4, 9, 16, 25]

// Shorthand syntax for simple functions (arrow functions)
door cubes = numbers.map(num => num * num * num)
qor(cubes)  // Outputs: [1, 8, 27, 64, 125]

// Higher-order function that takes a function as an argument
howl applyToEach(array, func) {
    door results = []
    ku_celi item ku dhex jira array {
        results.push(func(item))
    }
    soo_celi results
}

door numbers = [1, 2, 3, 4, 5]
door doubled = applyToEach(numbers, num => num * 2)
qor(doubled)  // Outputs: [2, 4, 6, 8, 10]

// Higher-order function that returns a function
howl multiplier(factor) {
    soo_celi howl(number) {
        soo_celi number * factor
    }
}

door double = multiplier(2)
door triple = multiplier(3)

qor(double(5))  // Outputs: 10
qor(triple(5))  // Outputs: 15

// Chaining higher-order functions
howl filterMap(array, predicate, transform) {
    door results = []
    ku_celi item ku dhex jira array {
        haddii (predicate(item)) {
            results.push(transform(item))
        }
    }
    soo_celi results
}

// Get squares of even numbers
door numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
door evenSquares = filterMap(
    numbers,
    num => num % 2 == 0,  // Filter for even numbers
    num => num * num      // Transform by squaring
)
qor(evenSquares)  // Outputs: [4, 16, 36, 64, 100]

// Factorial function using recursion
howl factorial(n) {
    haddii (n <= 1) {
        soo_celi 1
    }
    soo_celi n * factorial(n - 1)
}

qor(factorial(5))  // Outputs: 120 (5 * 4 * 3 * 2 * 1)

// Fibonacci sequence using recursion
howl fibonacci(n) {
    haddii (n <= 0) {
        soo_celi 0
    } laq_heli (n == 1) {
        soo_celi 1
    }
    soo_celi fibonacci(n - 1) + fibonacci(n - 2)
}

qor(fibonacci(7))  // Outputs: 13

// Tree traversal using recursion
howl createNode(value, left = null, right = null) {
    soo_celi { value, left, right }
}

// Creating a simple binary tree
door root = createNode(1,
    createNode(2, 
        createNode(4), 
        createNode(5)
    ),
    createNode(3, 
        createNode(6), 
        createNode(7)
    )
)

// In-order traversal (Left -> Root -> Right)
howl inorder_traverse(node) {
    haddii (node == null) {
        soo_celi []
    }
    
    door results = []
    results = results.concat(inorder_traverse(node.left))
    results.push(node.value)
    results = results.concat(inorder_traverse(node.right))
    
    soo_celi results
}

qor(inorder_traverse(root))  // Outputs: [4, 2, 5, 1, 6, 3, 7]