Returning Values from Functions

Functions become truly effective when they can provide a result back to the part of your program that called them. This result is known as a return value. It's the outcome of the function's calculations or processing steps. Imagine a function as a focused assistant: you provide it with instructions and materials (arguments), it performs its designated task, and then it hands back the completed item (the return value). This mechanism allows you to chain functions together, using the output of one as the input for another, or to store a function's result in a variable for later use, enabling you to construct more sophisticated program logic.

Explicitly Returning Values with return

The most straightforward method to specify what a function should send back is by using the return keyword. When Julia encounters return inside a function, it immediately stops the function's execution and sends the value following return back to the point where the function was called.

Here’s a simple function that adds two numbers and returns their sum:

function add_numbers(x, y)
    calculation_result = x + y
    return calculation_result
end

sum_value = add_numbers(5, 3)
println("The sum is: $sum_value") # Output: The sum is: 8

In this code, add_numbers(5, 3) is invoked. Inside the function, x is assigned 5 and y is 3. Their sum, 8, is computed and stored in calculation_result. The statement return calculation_result then sends this value 8 back, and it's assigned to the sum_value variable.

The return keyword also serves as an immediate exit from the function. Any code within the function that comes after an executed return statement will not be run.

Consider this example:

function check_number_type(number)
    if number > 0
        return "Positive"
    end
    # This part is only reached if number is not greater than 0
    return "Not positive (zero or negative)"
    println("This line will not be executed.") # Unreachable code
end

message_one = check_number_type(10)
println(message_one) # Output: Positive

message_two = check_number_type(-2)
println(message_two) # Output: Not positive (zero or negative)

When check_number_type(10) is called, the condition number > 0 is true, so the string "Positive" is returned, and the function terminates. The println statement at the very end of the function definition is never reached in this call.

Implicit Returns: A Julia Convenience

Julia includes a helpful feature: if a function does not contain an explicit return statement that gets executed for a particular path of execution, the value of the very last expression evaluated within the function is automatically returned. This can lead to more compact code, particularly for short, simple functions.

Let's rewrite our add_numbers function to utilize an implicit return:

function add_numbers_implicit(x, y)
    calculation_result = x + y
    calculation_result # This is the last evaluated expression
end

implicit_sum_value = add_numbers_implicit(7, 2)
println("The implicit sum is: $implicit_sum_value") # Output: The implicit sum is: 9

Here, calculation_result is the last expression evaluated, so its value (9 in this instance) is returned automatically. This function could even be condensed to a single line:

function add_numbers_oneline(x, y)
    x + y # The result of x + y is the last expression evaluated
end

sum_from_oneline = add_numbers_oneline(3, 4)
println("One-line sum: $sum_from_oneline") # Output: One-line sum: 7

While implicit returns are common in Julia and contribute to its conciseness, it's often a good practice, especially for those new to Julia, to use an explicit return. This clearly states your intent and can make your functions easier to read and understand, particularly if they are longer or have multiple conditions leading to different return points.

Returning Multiple Values

There are times when a function needs to provide more than one piece of information as its output. Julia manages this elegantly by allowing functions to return multiple values. When you list multiple values after return (or as the last expression for an implicit return), separated by commas, Julia automatically groups them into a data structure called a tuple.

Suppose you need a function that calculates both the sum and the product of two numbers:

function calculate_sum_and_product(a, b)
    current_sum = a + b
    current_product = a * b
    return current_sum, current_product # Returns a tuple (current_sum, current_product)
end

all_results = calculate_sum_and_product(4, 5)
println("Raw results: $all_results")        # Output: Raw results: (9, 20)
println("Type of results: $(typeof(all_results))") # Output: Type of results: Tuple{Int64, Int64}

The calculate_sum_and_product function returns two values, current_sum and current_product. These are packaged into the tuple (9, 20), which is then assigned to the all_results variable.

A very convenient aspect of this feature is that you can directly assign these returned values to separate variables on the calling side. This is sometimes called destructuring assignment:

my_calculated_sum, my_calculated_product = calculate_sum_and_product(3, 7)
println("Sum: $my_calculated_sum")          # Output: Sum: 10
println("Product: $my_calculated_product")    # Output: Product: 21

This offers a clean way to obtain multiple results from a single function call. If you are interested in only some of the returned values, you can use an underscore _ as a placeholder for any values you wish to ignore:

just_the_sum, _ = calculate_sum_and_product(10, 2) # We only need the sum here
println("Just the sum: $just_the_sum") # Output: Just the sum: 12

Functions Performing Actions: Returning nothing

Not all functions are designed primarily to compute and return a new value. Some functions are executed mainly for their side effects, such as printing text to the console, modifying an existing data structure that was passed as an argument, or writing to a file. For example, the println() function displays output; its primary role isn't to return a calculated value for further use.

What do such functions return? In Julia, if a function doesn't have an explicit return statement for a given execution path, and its last evaluated expression doesn't inherently produce a specific value (like println() itself), it implicitly returns a special value called nothing. The nothing object is the sole instance of its type, Nothing, and represents the absence of a value.

Consider this function:

function display_greeting(name)
    println("Hello, $name! Pleased to meet you.")
    # No explicit return statement here.
    # The last operation, println, returns nothing.
end

output_from_greeting = display_greeting("Dana")
println("The display_greeting function returned: $output_from_greeting")
# Output:
# Hello, Dana! Pleased to meet you.
# The display_greeting function returned: nothing

The display_greeting function performs its task of printing a message. Since it doesn't explicitly return anything, and println itself returns nothing, the output_from_greeting variable is assigned nothing.

It is perfectly normal for functions to return nothing. This often indicates that the function's main purpose was achieved through actions (side effects) rather than by producing a new value intended for subsequent computations.

Grasping how functions return values is a foundation of writing effective Julia programs. Whether you employ an explicit return for clarity, use an implicit return for conciseness in simple functions, or manage multiple results through tuples, understanding this aspect enables you to construct modular and effective programs where different components can communicate and build upon each other's outputs.