🎛️ Lesson 4.2: Parameters, Arguments, and Return Values

# Default values go in the function definition
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")               # Hello, Alice!  (uses default)
greet("Bob", "Good morning") # Good morning, Bob!  (overrides default)

# Multiple defaults
def create_user(name, role="viewer", active=True):
    print(f"User: {name}, Role: {role}, Active: {active}")

create_user("Alice")                        # viewer, True
create_user("Bob", "admin")                 # admin, True
create_user("Charlie", "editor", False)     # editor, False

// Default values with = in the parameter list
function greet(name, greeting = "Hello") {
    console.log(`${greeting}, ${name}!`);
}

greet("Alice");                // Hello, Alice!
greet("Bob", "Good morning"); // Good morning, Bob!

// Multiple defaults
function createUser(name, role = "viewer", active = true) {
    console.log(`User: ${name}, Role: ${role}, Active: ${active}`);
}

createUser("Alice");                        // viewer, true
createUser("Bob", "admin");                 // admin, true
createUser("Charlie", "editor", false);     // editor, false

// Default values with = (called "optional parameters")
static void Greet(string name, string greeting = "Hello")
{
    Console.WriteLine($"{greeting}, {name}!");
}

Greet("Alice");                // Hello, Alice!
Greet("Bob", "Good morning"); // Good morning, Bob!

// Multiple defaults
static void CreateUser(string name, string role = "viewer", bool active = true)
{
    Console.WriteLine($"User: {name}, Role: {role}, Active: {active}");
}

CreateUser("Alice");                        // viewer, True
CreateUser("Bob", "admin");                 // admin, True
CreateUser("Charlie", "editor", false);     // editor, False

def create_user(name, role="viewer", active=True, email=None):
    print(f"Name: {name}")
    print(f"Role: {role}")
    print(f"Active: {active}")
    print(f"Email: {email or 'Not provided'}")
    print()

# Positional: must be in order
create_user("Alice", "admin", True, "alice@example.com")

# Keyword: any order, self-documenting
create_user("Bob", email="bob@example.com", role="editor")

# Mix positional and keyword (positional must come first)
create_user("Charlie", "admin", email="charlie@example.com")

# Skip middle defaults easily:
create_user("Diana", active=False)  # role stays "viewer"

// JavaScript doesn't have built-in keyword args
// Instead, use an options OBJECT (very common pattern)

function createUser({ name, role = "viewer", active = true, email = null }) {
    console.log(`Name: ${name}`);
    console.log(`Role: ${role}`);
    console.log(`Active: ${active}`);
    console.log(`Email: ${email || "Not provided"}`);
    console.log();
}

// Pass an object — order doesn't matter
createUser({ name: "Alice", role: "admin", email: "alice@example.com" });
createUser({ name: "Bob", email: "bob@example.com", role: "editor" });

// Skip any defaults you don't need
createUser({ name: "Charlie", active: false });

// This "options object" pattern is everywhere in JavaScript:
// fetch(url, { method: "POST", headers: {...} })
// addEventListener("click", handler, { once: true })

// C# supports named arguments with the name: value syntax
static void CreateUser(string name, string role = "viewer",
    bool active = true, string email = null)
{
    Console.WriteLine($"Name: {name}");
    Console.WriteLine($"Role: {role}");
    Console.WriteLine($"Active: {active}");
    Console.WriteLine($"Email: {email ?? "Not provided"}");
    Console.WriteLine();
}

// Positional
CreateUser("Alice", "admin", true, "alice@example.com");

// Named: any order (after positional args)
CreateUser("Bob", email: "bob@example.com", role: "editor");

// Skip middle defaults
CreateUser("Charlie", active: false);

// C# named args look like Python keyword args!
// The key difference: C# also has method overloading (see below)

# *args collects extra positional arguments into a tuple
def add_all(*numbers):
    total = sum(numbers)
    print(f"Sum of {numbers} = {total}")
    return total

add_all(1, 2, 3)          # Sum of (1, 2, 3) = 6
add_all(10, 20, 30, 40)   # Sum of (10, 20, 30, 40) = 100

# **kwargs collects extra keyword arguments into a dictionary
def print_info(name, **details):
    print(f"Name: {name}")
    for key, value in details.items():
        print(f"  {key}: {value}")

print_info("Alice", age=30, city="NYC", role="developer")
# Name: Alice
#   age: 30
#   city: NYC
#   role: developer

# You can use both together:
def flexible(required, *args, **kwargs):
    print(f"Required: {required}")
    print(f"Extra args: {args}")
    print(f"Extra kwargs: {kwargs}")

// Rest parameter (...) collects remaining args into an array
function addAll(...numbers) {
    let total = numbers.reduce((sum, n) => sum + n, 0);
    console.log(`Sum of [${numbers}] = ${total}`);
    return total;
}

addAll(1, 2, 3);          // Sum of [1,2,3] = 6
addAll(10, 20, 30, 40);   // Sum of [10,20,30,40] = 100

// Rest must be the last parameter
function greetAll(greeting, ...names) {
    for (let name of names) {
        console.log(`${greeting}, ${name}!`);
    }
}
greetAll("Hello", "Alice", "Bob", "Charlie");

// Spread operator (...) does the opposite — unpacks an array
let nums = [1, 2, 3, 4, 5];
console.log(Math.max(...nums));  // 5 (spreads array into arguments)

// params keyword collects extra arguments into an array
static int AddAll(params int[] numbers)
{
    int total = numbers.Sum();
    Console.WriteLine($"Sum of [{string.Join(", ", numbers)}] = {total}");
    return total;
}

AddAll(1, 2, 3);          // Sum of [1, 2, 3] = 6
AddAll(10, 20, 30, 40);   // Sum of [10, 20, 30, 40] = 100

// params must be the last parameter and there can only be one
static void GreetAll(string greeting, params string[] names)
{
    foreach (string name in names)
    {
        Console.WriteLine($"{greeting}, {name}!");
    }
}
GreetAll("Hello", "Alice", "Bob", "Charlie");

// You can also pass an array directly:
string[] people = { "Diana", "Eve" };
GreetAll("Hi", people);

# Python doesn't have overloading — use default params instead
def calculate_area(width, height=None):
    if height is None:
        # Treat as a square
        return width * width
    return width * height

print(calculate_area(5))       # 25 (square)
print(calculate_area(5, 3))    # 15 (rectangle)

# Or use *args for more flexibility:
def greet(*args):
    if len(args) == 1:
        print(f"Hello, {args[0]}!")
    elif len(args) == 2:
        print(f"{args[1]}, {args[0]}!")

greet("Alice")               # Hello, Alice!
greet("Alice", "Good morning")  # Good morning, Alice!

// JavaScript doesn't have overloading — use defaults or type checks
function calculateArea(width, height = null) {
    if (height === null) {
        return width * width;  // square
    }
    return width * height;     // rectangle
}

console.log(calculateArea(5));      // 25 (square)
console.log(calculateArea(5, 3));   // 15 (rectangle)

// Or check argument types:
function format(value) {
    if (typeof value === "number") {
        return value.toFixed(2);
    } else if (typeof value === "string") {
        return value.toUpperCase();
    }
    return String(value);
}

console.log(format(3.14159));   // "3.14"
console.log(format("hello"));  // "HELLO"

// C# method overloading — same name, different parameters
static double CalculateArea(double side)
{
    // Square: one parameter
    return side * side;
}

static double CalculateArea(double width, double height)
{
    // Rectangle: two parameters
    return width * height;
}

static double CalculateArea(double radius, bool isCircle)
{
    // Circle: radius + flag
    return Math.PI * radius * radius;
}

// The compiler picks the right version automatically:
Console.WriteLine(CalculateArea(5));           // 25 (square)
Console.WriteLine(CalculateArea(5, 3));        // 15 (rectangle)
Console.WriteLine(CalculateArea(5, true));     // 78.54 (circle)

// Overloading also works with different types:
static string Format(int value) => value.ToString("N0");
static string Format(double value) => value.ToString("F2");
static string Format(string value) => value.ToUpper();

Console.WriteLine(Format(1000));      // "1,000"
Console.WriteLine(Format(3.14159));   // "3.14"
Console.WriteLine(Format("hello"));   // "HELLO"

# ❌ Deeply nested — hard to follow
def process_order_nested(item, quantity, price):
    if item:
        if quantity > 0:
            if price > 0:
                total = quantity * price
                return f"Order: {quantity}x {item} = ${total:.2f}"
            else:
                return "Error: Invalid price"
        else:
            return "Error: Invalid quantity"
    else:
        return "Error: No item specified"

# ✅ Early returns — flat and clean
def process_order(item, quantity, price):
    if not item:
        return "Error: No item specified"
    if quantity <= 0:
        return "Error: Invalid quantity"
    if price <= 0:
        return "Error: Invalid price"

    total = quantity * price
    return f"Order: {quantity}x {item} = ${total:.2f}"

print(process_order("Widget", 3, 9.99))   # Order: 3x Widget = $29.97
print(process_order("", 3, 9.99))          # Error: No item specified
print(process_order("Widget", -1, 9.99))   # Error: Invalid quantity

// ✅ Early returns — guard clauses at the top
function processOrder(item, quantity, price) {
    if (!item) return "Error: No item specified";
    if (quantity <= 0) return "Error: Invalid quantity";
    if (price <= 0) return "Error: Invalid price";

    let total = quantity * price;
    return `Order: ${quantity}x ${item} = $${total.toFixed(2)}`;
}

console.log(processOrder("Widget", 3, 9.99));
console.log(processOrder("", 3, 9.99));
console.log(processOrder("Widget", -1, 9.99));

// ✅ Early returns — guard clauses at the top
static string ProcessOrder(string item, int quantity, decimal price)
{
    if (string.IsNullOrEmpty(item)) return "Error: No item specified";
    if (quantity <= 0) return "Error: Invalid quantity";
    if (price <= 0) return "Error: Invalid price";

    decimal total = quantity * price;
    return $"Order: {quantity}x {item} = {total:C}";
}

Console.WriteLine(ProcessOrder("Widget", 3, 9.99m));
Console.WriteLine(ProcessOrder("", 3, 9.99m));
Console.WriteLine(ProcessOrder("Widget", -1, 9.99m));

# Numbers, strings, booleans: changes inside don't affect outside
def try_to_change(x):
    x = 999
    print(f"Inside: x = {x}")

num = 42
try_to_change(num)
print(f"Outside: num = {num}")  # Still 42!

# Lists, dicts: changes inside DO affect outside
def add_item(items):
    items.append("new item")
    print(f"Inside: {items}")

my_list = ["a", "b"]
add_item(my_list)
print(f"Outside: {my_list}")  # ['a', 'b', 'new item'] — changed!

# Why? Python passes a reference to the object.
# Numbers are immutable (x = 999 creates a NEW number).
# Lists are mutable (append modifies the SAME list).

// Primitives (numbers, strings, booleans): copied
function tryToChange(x) {
    x = 999;
    console.log(`Inside: x = ${x}`);
}

let num = 42;
tryToChange(num);
console.log(`Outside: num = ${num}`);  // Still 42!

// Objects and arrays: reference is shared
function addItem(items) {
    items.push("new item");
    console.log(`Inside: ${items}`);
}

let myList = ["a", "b"];
addItem(myList);
console.log(`Outside: ${myList}`);  // ['a', 'b', 'new item']

// Same rule: primitives are copied, objects/arrays are shared

// Value types (int, double, bool, struct): copied
static void TryToChange(int x)
{
    x = 999;
    Console.WriteLine($"Inside: x = {x}");
}

int num = 42;
TryToChange(num);
Console.WriteLine($"Outside: num = {num}");  // Still 42!

// Reference types (arrays, lists, objects): reference shared
static void AddItem(List<string> items)
{
    items.Add("new item");
    Console.WriteLine($"Inside: [{string.Join(", ", items)}]");
}

var myList = new List<string> { "a", "b" };
AddItem(myList);
Console.WriteLine($"Outside: [{string.Join(", ", myList)}]");
// [a, b, new item] — changed!

// C# also has explicit ref and out keywords:
static void DoubleIt(ref int x) { x *= 2; }

int value = 5;
DoubleIt(ref value);
Console.WriteLine(value);  // 10 — actually changed!