Julia Operators and Expressions

Julia's arithmetic operators are what you'd expect — +, -, *, / — plus a few numeric-computing specifics: ÷ (typed \div<Tab>, or the function div) performs integer (truncating) division, % computes the remainder, and ^ is exponentiation, so 2^10 is 1024 and 7 ÷ 2 is 3 while 7 / 2 is 3.5. Comparison operators (==, !=, <, <=, >, >=) can be chained the way mathematical notation allows, so 0 < x < 10 correctly checks both bounds in one expression instead of requiring 0 < x && x < 10.

The dot syntax — appending . to any function or operator — broadcasts it elementwise across arrays (or any iterable), so [1, 2, 3] .+ 1 yields [2, 3, 4] and sin.(x) applies sin to every element of the array x without writing an explicit loop. This is more than syntactic sugar for convenience: Julia's compiler fuses chains of broadcasted operations like y = sin.(x) .+ cos.(x) .^ 2 into a single loop with no intermediate array allocations, so broadcasting is often the idiomatic, high-performance way to write vectorized code rather than a slow shortcut.

&& and || are short-circuiting: in a && b, b is only evaluated if a is true, and in a || b, b is only evaluated if a is false — which Julia idiom exploits for control flow, as in x > 0 || error("x must be positive"), where error only runs (and throws) when the condition is false. This differs from the elementwise, non-short-circuiting & and | bitwise operators, which are used specifically for broadcasting over Boolean arrays, such as (x .> 0) .& (x .< 10) to build a combined elementwise mask.

Julia is expression-oriented: if/else blocks, for loops, and even begin...end blocks all evaluate to a value (the value of their last executed line), which is why the ternary operator cond ? a : b is really just syntax for a compact if cond; a; else; b; end — status = age >= 18 ? "adult" : "minor" assigns directly from the branch taken. This expression-oriented design lets you write things like y = if x > 0; 1; else; -1; end naturally, and it underlies why a function's return value defaults to whatever its last expression evaluates to, without needing an explicit return.

Every infix operator in Julia is ordinary syntax sugar for a function call — 1 + 2 is exactly equivalent to +(1, 2), and you can call + like any other function or even pass it as a value, e.g. reduce(+, [1, 2, 3, 4]) to sum a list. Because operators are just functions, you can extend them for your own types using multiple dispatch: defining import Base: +; +(a::Point, b::Point) = Point(a.x + b.x, a.y + b.y) teaches Julia how + should behave for two Point values, letting user-defined types participate in ordinary arithmetic syntax.