ruchy 4.2.0

// 15_modules.ruchy - Module system and code organization

// Math utilities module with nested geometry module
module math_utils {
    pub fn add(a, b) {
        a + b
    }

    pub fn multiply(a, b) {
        a * b
    }

    // Private helper function (not exported)
    fn internal_helper(x) {
        x * 2
    }

    // Public function that calls private helper
    pub fn complex_calc(x, y) {
        let temp = internal_helper(x)
        temp + multiply(y, 2)
    }

    // Nested geometry module
    pub module geometry {
        pub fn area_circle(radius) {
            3.14159 * radius * radius
        }

        pub fn area_rectangle(width, height) {
            width * height
        }

        pub fn perimeter_rectangle(width, height) {
            2 * (width + height)
        }
    }

    // Constants as functions (pub const not yet supported)
    pub fn PI() {
        3.14159
    }

    pub fn E() {
        2.71828
    }
}

// String utilities module
module string_utils {
    pub fn capitalize(s) {
        if s.len() == 0 {
            return s
        }
        let first = s[0].upper()
        let chars = s.chars()
        let rest = chars[1..].join("")
        first + rest
    }

    // Internal helper for reversing
    fn reverse_chars(chars) {
        let mut reversed = []
        let mut i = chars.len() - 1
        while i >= 0 {
            reversed.push(chars[i])
            i -= 1
        }
        reversed
    }

    pub fn reverse(s) {
        let chars = s.chars()
        let reversed = reverse_chars(chars)
        reversed.join("")
    }

    pub fn is_palindrome(s) {
        let cleaned = s.lower().replace(" ", "")
        let reversed = reverse(cleaned)
        cleaned == reversed
    }

    pub fn word_count(text) {
        text.split(" ").filter(w => w.len() > 0).len()
    }
}

// Main execution
println("=== Module System ===\n")

// Using module functions
println("=== Math Utils Module ===")

let sum = math_utils::add(10, 20)
println(f"10 + 20 = {sum}")

let product = math_utils::multiply(5, 6)
println(f"5 * 6 = {product}")

// Call function that uses private helper
let complex = math_utils::complex_calc(3, 4)
println(f"Complex calculation (uses internal helper): {complex}")

// Using nested geometry module
println("\n=== Nested Geometry Module ===")

let circle_area = math_utils::geometry::area_circle(5.0)
println(f"Area of circle (r=5): {circle_area}")

let rect_area = math_utils::geometry::area_rectangle(10.0, 20.0)
println(f"Area of rectangle (10x20): {rect_area}")

let perimeter = math_utils::geometry::perimeter_rectangle(10.0, 20.0)
println(f"Perimeter of rectangle: {perimeter}")

// Using constants (as functions)
let pi_val = math_utils::PI()
let e_val = math_utils::E()
println(f"PI constant: {pi_val}")
println(f"E constant: {e_val}")

// String utilities
println("\n=== String Utils Module ===")

let text = "hello world"
let capitalized = string_utils::capitalize(text)
println(f"Capitalized: {capitalized}")

let reversed = string_utils::reverse(text)
println(f"Reversed: {reversed}")

let palindrome1 = "racecar"
let palindrome2 = "hello"
let is_pal1 = string_utils::is_palindrome(palindrome1)
let is_pal2 = string_utils::is_palindrome(palindrome2)
println(f"Is '{palindrome1}' a palindrome? {is_pal1}")
println(f"Is '{palindrome2}' a palindrome? {is_pal2}")

let sentence = "The quick brown fox jumps"
let count = string_utils::word_count(sentence)
println(f"Word count: {count}")