Julia Tuples

Tuples are immutable ordered collections in Julia that can contain elements of different types. Once created, tuples cannot be modified, making them suitable for returning multiple values from functions or storing fixed data combinations.

Creating Tuples

Basic Creation

# Using parentheses
t = (1, 2, 3)
println(t)  # (1, 2, 3)

# Mixed types
t = (1, "hello", 3.14, true)
println(t)  # (1, "hello", 3.14, true)

# Single element tuple needs comma
single = (1,)     # Tuple
not_tuple = (1)   # Just number 1

# Empty tuple
empty = ()

Omitting Parentheses

Parentheses can be omitted in some cases:

# Assignment can omit parentheses
t = 1, 2, 3
println(t)  # (1, 2, 3)

# Function returning multiple values
function minmax(a, b)
    return a < b ? (a, b) : (b, a)
end
result = minmax(5, 3)
println(result)  # (3, 5)

Accessing Elements

Index Access

Tuple indexing starts at 1:

t = (10, 20, 30, 40, 50)

# Access single element
println(t[1])    # 10
println(t[end])  # 50

# Range access
println(t[2:4])  # (20, 30, 40)

Destructuring (Unpacking)

t = (1, 2, 3)

# Destructure to variables
a, b, c = t
println(a)  # 1
println(b)  # 2
println(c)  # 3

# Swap variables
x, y = 10, 20
x, y = y, x
println("x=$x, y=$y")  # x=20, y=10

# Ignore some values
first, _, third = (1, 2, 3)
println(first)  # 1
println(third)  # 3

# Collect remaining elements
first, rest... = (1, 2, 3, 4, 5)
println(first)  # 1
println(rest)   # (2, 3, 4, 5)

Tuple Properties

t = (1, "hello", 3.14)

# Length
println(length(t))  # 3

# Type
println(typeof(t))  # Tuple{Int64, String, Float64}

# Check if contains element
println(1 in t)       # true
println("world" in t) # false

Immutability

Tuples cannot be modified after creation:

t = (1, 2, 3)

# Attempting to modify throws error
# t[1] = 100  # ERROR: MethodError

# But if tuple contains mutable objects, the object itself can be modified
t = ([1, 2], [3, 4])
t[1][1] = 100  # This is allowed
println(t)     # ([100, 2], [3, 4])

Named Tuples

Named tuples (NamedTuple) are tuples with field names, allowing access by name.

Creating Named Tuples

# Using = syntax
person = (name="Alice", age=30, city="Beijing")
println(person)  # (name = "Alice", age = 30, city = "Beijing")

# Using NamedTuple constructor
nt = NamedTuple{(:x, :y)}((1, 2))
println(nt)  # (x = 1, y = 2)

# Create from variables
name = "Bob"
age = 25
person = (; name, age)  # Use variable names as field names
println(person)  # (name = "Bob", age = 25)

Accessing Named Tuples

person = (name="Alice", age=30, city="Beijing")

# Access by name
println(person.name)  # Alice
println(person.age)   # 30

# Can also access by index
println(person[1])    # Alice

# Get all keys
println(keys(person))    # (:name, :age, :city)

# Get all values
println(values(person))  # ("Alice", 30, "Beijing")

Named Tuple Destructuring

person = (name="Alice", age=30)

# Destructure by name
(; name, age) = person
println(name)  # Alice
println(age)   # 30

# Rename
(; name => n, age => a) = person
println(n)  # Alice

Tuple Operations

Merging Tuples

t1 = (1, 2, 3)
t2 = (4, 5, 6)

# Using ... to expand
combined = (t1..., t2...)
println(combined)  # (1, 2, 3, 4, 5, 6)

Named Tuple Merging

nt1 = (a=1, b=2)
nt2 = (c=3, d=4)

# Merge
combined = (; nt1..., nt2...)
println(combined)  # (a = 1, b = 2, c = 3, d = 4)

# Override fields
nt1 = (a=1, b=2)
nt2 = (b=10, c=3)
combined = (; nt1..., nt2...)
println(combined)  # (a = 1, b = 10, c = 3)

Iterating Tuples

t = (1, 2, 3, 4, 5)

# for loop
for x in t
    println(x)
end

# Iterate with index
for (i, x) in enumerate(t)
    println("Index $i: Value $x")
end

# Iterate named tuple
person = (name="Alice", age=30)
for (key, value) in pairs(person)
    println("$key: $value")
end

Conversion Operations

t = (1, 2, 3, 4, 5)

# Convert to array
arr = collect(t)
println(arr)  # [1, 2, 3, 4, 5]

# Array to tuple
arr = [1, 2, 3]
t = Tuple(arr)
println(t)  # (1, 2, 3)

# Named tuple to dictionary
person = (name="Alice", age=30)
d = Dict(pairs(person))
println(d)  # Dict(:name => "Alice", :age => 30)

Functions and Tuples

Returning Multiple Values

function divrem_custom(a, b)
    return (a ÷ b, a % b)
end

quotient, remainder = divrem_custom(17, 5)
println("Quotient: $quotient, Remainder: $remainder")  # Quotient: 3, Remainder: 2

Tuple as Arguments

# Using splatting to expand tuple as arguments
function add3(a, b, c)
    return a + b + c
end

args = (1, 2, 3)
result = add3(args...)
println(result)  # 6

Variadic Functions

# Variadic arguments as tuple
function show_all(args...)
    println("Received $(length(args)) arguments")
    for arg in args
        println("  - $arg")
    end
end

show_all(1, 2, 3, "hello")

Tuple Comparison

t1 = (1, 2, 3)
t2 = (1, 2, 3)
t3 = (1, 2, 4)

# Equality comparison
println(t1 == t2)  # true
println(t1 == t3)  # false

# Size comparison (lexicographic)
println(t1 < t3)   # true (because 3 < 4)
println((1, 2) < (1, 2, 3))  # true (shorter is smaller)

Common Use Cases

1. Function Returning Multiple Values

function analyze(data)
    n = length(data)
    total = sum(data)
    avg = total / n
    return (count=n, sum=total, average=avg)
end

result = analyze([1, 2, 3, 4, 5])
println(result.average)  # 3.0

2. Dictionary Keys

# Tuples can be dictionary keys
locations = Dict{Tuple{Int,Int}, String}()
locations[(0, 0)] = "Origin"
locations[(1, 2)] = "Point A"

println(locations[(0, 0)])  # Origin

3. Multiple Assignment and Swap

# Swap variables
a, b = 1, 2
a, b = b, a

# Simultaneous assignment
x, y, z = 1, 2, 3

4. Configuration Parameters

config = (
    host = "localhost",
    port = 8080,
    debug = true,
    timeout = 30
)

println("Server: $(config.host):$(config.port)")

Tuple vs Array

Feature	Tuple	Array
Mutability	Immutable	Mutable
Types	Can mix types	Usually same type
Performance	Types known, faster	Slightly slower
Use case	Fixed structure data	Dynamic collections

# Tuple: type known at compile time
t = (1, "hello", 3.14)
println(typeof(t))  # Tuple{Int64, String, Float64}

# Array: uniform element type
arr = [1, 2, 3]
println(typeof(arr))  # Vector{Int64}

Next Steps

After learning tuples, continue with:

• Data Types - Deep dive into type system
• Dictionaries and Sets - Other data structures
• Functions - Function definition and usage