Variadic Functions and Splatting

Introduction

Welcome back to Julia Functions and Functional Programming! You're making excellent progress in this comprehensive course, having mastered the fundamentals of function definition and multiple return values in our previous lesson. Now, we're ready to explore one of Julia's most powerful and flexible features: variadic functions and the splat operator . These tools will dramatically expand your ability to create functions that work seamlessly with varying numbers of arguments. Building on your solid foundation of function syntax and tuple handling, we'll discover how to write functions that accept any number of arguments and learn to unpack collections into individual function parameters. These capabilities enable elegant solutions for mathematical operations, data processing, and function composition patterns that would be cumbersome with fixed parameter lists. By the end of this lesson, you'll wield the flexibility to create functions that adapt gracefully to different calling contexts while maintaining clean, readable code.

Understanding Variadic Functions

Variadic functions represent a fundamental programming pattern that allows functions to accept a variable number of arguments rather than a fixed parameter count. This flexibility proves invaluable when creating mathematical operations like summation or averaging, where the number of input values may vary depending on the specific use case. In Julia, variadic functions use the ellipsis notation (...) after a parameter name to capture any number of additional arguments into a tuple. This mechanism provides the foundation for creating highly flexible functions that can work with one argument, ten arguments, or even zero arguments, depending on the calling context. The captured arguments become available as a standard tuple within the function body, allowing iteration, indexing, and all other tuple operations.

Basic Variadic Function Implementation

Let's begin with the simplest variadic function that demonstrates the core syntax and behavior: Julia # Variadic function: returns received arguments as a tuple varargs(args...) = args # args is a tuple # Variadic function: returns received arguments as a tuple varargs(args...) = args # args is a tuple This compact function definition showcases the essential variadic syntax using args... to capture any number of arguments. The parameter args becomes a tuple containing all passed arguments, which we return directly. The ellipsis ... after the parameter name signals to Julia that this function should accept any number of arguments and package them into the named tuple parameter.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Julia

# Variadic function: returns received arguments as a tuple
varargs(args...) = args          # args is a tuple

Julia

println(varargs())
println(varargs(1))
println(varargs(1, 2, 3))

println(varargs())
println(varargs(1))
println(varargs(1, 2, 3))

text

()
(1,)
(1, 2, 3)

Julia

function sum_all(nums...)
    total = 0
    for n in nums
        total += n
    end
    total
end

function sum_all(nums...)
    total = 0
    for n in nums
        total += n
    end
    total
end

text

sum_all(1,2,3) = 6

sum_all(1,2,3) = 6

Julia

add(x, y) = x + y

# Demonstrate splat operator in a call
pair_vec = [5, 6]
println("add(pair_vec...) = ", add(pair_vec...))   # same as add(5, 6)

pair_tup = (7, 8)
println("add(pair_tup...) = ", add(pair_tup...))

add(x, y) = x + y

# Demonstrate splat operator in a call
pair_vec = [5, 6]
println("add(pair_vec...) = ", add(pair_vec...))   # same as add(5, 6)

pair_tup = (7, 8)
println("add(pair_tup...) = ", add(pair_tup...))

text

add(pair_vec...) = 11
add(pair_tup...) = 15

add(pair_vec...) = 11
add(pair_tup...) = 15

Julia

function describe_variadic(first, rest...)
    println("first = $first")
    println("rest  = ", rest)
end

describe_variadic("alpha")                      # only required arg
describe_variadic("alpha", "beta", "gamma")     # extra args captured

function describe_variadic(first, rest...)
    println("first = $first")
    println("rest  = ", rest)
end

describe_variadic("alpha")                      # only required arg
describe_variadic("alpha", "beta", "gamma")     # extra args captured

text

first = alpha
rest  = ()
first = alpha
rest  = ("beta", "gamma")

first = alpha
rest  = ()
first = alpha
rest  = ("beta", "gamma")

Julia

function forward_to_add(args...)
    add(args...)            # forwards to add
end

println("forward_to_add(9,1) = ", forward_to_add(9, 1))

function forward_to_add(args...)
    add(args...)            # forwards to add
end

println("forward_to_add(9,1) = ", forward_to_add(9, 1))

text

forward_to_add(9,1) = 10

forward_to_add(9,1) = 10

Julia

pairs = [(1, 1), (2, 3), (4, 5)]
results = [add(p...) for p in pairs]           # p is a tuple, splatted

pairs = [(1, 1), (2, 3), (4, 5)]
results = [add(p...) for p in pairs]           # p is a tuple, splatted

text

add results for pairs: [2, 5, 9]

add results for pairs: [2, 5, 9]

Julia

# Edge case: calling varargs with splat from an array of mixed types
mixed = [1, "two", 3.0]

# Edge case: calling varargs with splat from an array of mixed types
mixed = [1, "two", 3.0]

text

varargs(mixed...) = (1, "two", 3.0)

varargs(mixed...) = (1, "two", 3.0)

Julia

println(varargs())
println(varargs(1))
println(varargs(1, 2, 3))

text

()
(1,)
(1, 2, 3)

Julia

function sum_all(nums...)
    total = 0
    for n in nums
        total += n
    end
    total
end

text

sum_all(1,2,3) = 6

Julia

add(x, y) = x + y

# Demonstrate splat operator in a call
pair_vec = [5, 6]
println("add(pair_vec...) = ", add(pair_vec...))   # same as add(5, 6)

pair_tup = (7, 8)
println("add(pair_tup...) = ", add(pair_tup...))

text

add(pair_vec...) = 11
add(pair_tup...) = 15

Julia

function describe_variadic(first, rest...)
    println("first = $first")
    println("rest  = ", rest)
end

describe_variadic("alpha")                      # only required arg
describe_variadic("alpha", "beta", "gamma")     # extra args captured

text

first = alpha
rest  = ()
first = alpha
rest  = ("beta", "gamma")

Julia

function forward_to_add(args...)
    add(args...)            # forwards to add
end

println("forward_to_add(9,1) = ", forward_to_add(9, 1))

text

forward_to_add(9,1) = 10

Julia

pairs = [(1, 1), (2, 3), (4, 5)]
results = [add(p...) for p in pairs]           # p is a tuple, splatted

text

add results for pairs: [2, 5, 9]

Julia

# Edge case: calling varargs with splat from an array of mixed types
mixed = [1, "two", 3.0]

text

varargs(mixed...) = (1, "two", 3.0)

Introduction

Understanding Variadic Functions

Basic Variadic Function Implementation

Join the 1M+ learners on CodeSignal

Variadic Function Behavior

Processing Variadic Arguments

Understanding the Splat Operator

Splatting Arrays and Tuples

Mixing Fixed and Variadic Parameters

Argument Forwarding with Splat

Splat in Collection Processing

Handling Mixed Data Types

Conclusion and Next Steps