Nesting Function Calls. Functions as Arguments

Welcome back! In the previous lesson, we explored the concept of variable scope, diving into the distinctions and uses of local and global variables. This time, we'll explore nesting function calls and using functions as arguments in Ruby. These techniques enable you to write more modular and reusable code, enhancing the overall flexibility and maintainability of your programs.

In this lesson, you'll learn:

• How to nest function calls within each other.
• How to use functions as arguments to other functions.
• The benefits of these approaches to your code.

Let's kick off with an example:

def make_coffee()
    puts "Making coffee..."
    return "espresso"
end

def serve_coffee(coffee, name)
    puts "Serving coffee #{coffee} to #{name}"
end

def prepare_and_serve_coffee(name)
    coffee = make_coffee()
    serve_coffee(coffee, name)
end

prepare_and_serve_coffee("Alice")

In the above code, you can see the function make_coffee is called inside another function prepare_and_serve_coffee. Moreover, serve_coffee is subsequently called within the same prepare_and_serve_coffee function, illustrating a basic form of nesting function calls.

In Ruby, you can pass functions as arguments to other functions. This technique is known as higher-order functions. Here's an example:

def get_name()
    return "Bob"
end

prepare_and_serve_coffee(get_name()) # Output: Making coffee... Serving coffee espresso to Bob
prepare_and_serve_coffee(get_name) # Output: Making coffee... Serving coffee espresso to Bob

In the above code, the function get_name is passed as an argument to the prepare_and_serve_coffee function. The function get_name is called first, and its return value is then passed to the prepare_and_serve_coffee function. Notice that you can pass the function get_name with or without parentheses, as both are valid in Ruby.

Understanding and applying nested function calls and functions as arguments is essential for several reasons:

1. Code Organization: Nesting functions can help you break down complex tasks into smaller, manageable functions, making your code more organized.
2. Reusability: By using functions as arguments, you can create more generic and reusable functions, reducing redundancy and making your codebase cleaner.
3. Readability: With properly nested function calls and concise argument passing, your code becomes easier to understand, debug, and maintain.

For example, the function prepare_and_serve_coffee is more readable because it abstracts the steps of making and serving coffee into separate functions.

Ready to practice these new skills? Let's jump into the practice section to deepen your understanding and improve your capability to write efficient and flexible Ruby programs.