Functions in Julia

Analogy categoryAnalogies

Defining Functions

Functions are defined with the function keyword and a matching end, or, for simple one-liners, with assignment-like syntax: square(x) = x^2. Julia doesn't require an explicit return — the value of the last evaluated expression in the function body is returned automatically, though return is still used for early exits, e.g., inside a guard clause near the top of the function. Function and variable names conventionally use snake_case, while types use CamelCase.

🏏

Cricket analogy: A team's standard opening partnership routine doesn't need a written manual for a straightforward single over — everyone just knows the last ball's outcome stands as the over's result, similar to how Julia returns the last expression's value without needing an explicit return.

Positional, Optional, and Keyword Arguments

Positional arguments can have default values, letting callers omit them: function greet(name, greeting="Hello"); println("$greeting, $name!"); end lets greet("Ana") and greet("Ana", "Hi") both work. Defaults are evaluated left to right and can reference earlier positional arguments, e.g., function box(width, height=width) makes a square box by default when only width is supplied.

🏏

Cricket analogy: A net session defaults to facing the bowling machine at medium pace unless the batter explicitly requests express pace, similar to how a Julia function's default argument value is used unless the caller overrides it.

Keyword arguments are declared after a semicolon in the signature — function plot(x, y; color="blue", linewidth=1) — and must be passed by name at the call site, e.g., plot(xs, ys; color="red"), which makes call sites self-documenting for functions with many optional settings. Unlike positional arguments, keyword arguments can be supplied in any order, and Julia allows splatting a NamedTuple or Dict of keyword arguments into a call with plot(xs, ys; opts...).

🏏

Cricket analogy: Filling out a scorecard by explicitly labeling each field — 'runs: 42, balls: 30, fours: 5' — rather than relying on a fixed column order mirrors keyword arguments being passed by explicit name rather than position.

Julia's dispatch mechanism means a single function name can have many methods — plot(x, y), plot(x, y; color), and plot(x::Vector, y::Vector) can all coexist. The compiler picks the most specific applicable method at compile time based on the argument types, which is the foundation of multiple dispatch.

Multiple Return Values

Julia functions can return multiple values by simply returning a tuple: function minmax_pair(v); return minimum(v), maximum(v); end, and callers destructure them directly — lo, hi = minmax_pair(data). This avoids the need for an output struct or mutable reference parameters for the common case of a function producing two or three related results, and the underscore _ can be used to discard a value you don't need: _, hi = minmax_pair(data).

🏏

Cricket analogy: A single delivery can produce both a wicket and a boundary conceded in the rare case of a run-out attempt gone wrong, and the scorer records both outcomes together rather than needing two separate balls, like a Julia function returning a tuple of two related values at once.

The ! Convention for Mutating Functions

By strong convention, functions that mutate one of their arguments are named with a trailing !, such as push!(v, x), sort!(v), or empty!(d) — this is purely a naming convention enforced by community style, not by the language, but violating it is considered a serious API smell because callers rely on the ! to know whether their data will be modified in place. The non-mutating counterpart typically has the same name without the !, e.g., sort(v) returns a new sorted copy while sort!(v) sorts v in place and returns it.

🏏

Cricket analogy: A team's 'declared' status next to a captain's name on the scorecard is a clear visual marker signaling the innings state has changed irreversibly, similar to how the ! suffix on sort! signals the argument itself has been mutated in place.

julia

# One-liner and multi-line function, implicit return
square(x) = x^2
function classify(n)
    n < 0 && return "negative"     # early exit via explicit return
    iseven(n) ? "even" : "odd"     # last expression, implicitly returned
end

# Default and keyword arguments
function greet(name, greeting="Hello"; excited=false)
    punct = excited ? "!" : "."
    println("$greeting, $name$punct")
end
greet("Ana")                       # "Hello, Ana."
greet("Ben", "Hi"; excited=true)    # "Hi, Ben!"

# Multiple return values via tuple destructuring
function minmax_pair(v)
    return minimum(v), maximum(v)
end
lo, hi = minmax_pair([4, 1, 9, 2])

# Mutating vs non-mutating convention
v = [3, 1, 2]
w = sort(v)     # w is new, v unchanged
sort!(v)        # v is now sorted in place

Type annotations on function arguments (f(x::Int)) restrict which methods apply — they are not required for performance the way they are in statically typed languages, since Julia specializes automatically per call-site argument types. Over-annotating can actually reduce reusability by accidentally excluding valid types like Int32 when you meant any integer; use abstract types like Integer or leave arguments unannotated unless you specifically need to dispatch on the type.

function ... end or one-line f(x) = ... both define functions; the last expression's value is returned implicitly.
Positional arguments can have defaults (greeting="Hello") evaluated left to right.
Keyword arguments, declared after ; in the signature, are passed by name and can appear in any order.
Functions can return multiple values as a tuple, destructured at the call site like lo, hi = minmax_pair(v).
The trailing ! is a strong naming convention (not enforced by the language) for functions that mutate an argument.
sort(v) returns a new array; sort!(v) sorts v in place and returns it.
Type annotations on arguments narrow which method applies but aren't required for performance.