Синтаксические вкусности Julia

В этой статье я хочу рассказать про вкусные и полезные синтаксические плюшки Julia, которые должны подсластить горькую долю программиста.

Поехали!

Инфиксные операторы — это обычные функции

Инфиксные операции, такие как +, -, <, ==, in и другие (&& и || в этот список не входят, т.к. они не являются функциями из-за "короткозамкнутой" логики), являются обычными функциями (только со специальными правилами парсинга). Это значит, эти функции можно доопределять под свои типы данных.
Например, можно легко сделать тип данных для неупорядоченной пары объектов:

struct SetOfTwo{T}      a::T      b::T      function SetOfTwo(a::A, b::B) where {A,B}         if a != b             T = promote_type(A, B)             return new{T}(a, b)         else             throw(ArgumentError("Set elements must be distinct"))         end     end end

Сравнивать эти структуры данных будем без учёта порядка:

Base.in(x, s::SetOfTwo) = x == s.a || x == s.b  Base.:(==)(s1::SetOfTwo, s2::SetOfTwo) = (s1.a in s2) && (s1.b in s2)

Механизм множественной диспетчеризации даёт возможность добавлять также сравнения с объектами других типов по необходимости:

Base.:(==)(s1::SetOfTwo, s2::AbstractSet) = length(s2) == 2 && s1.a in s2 && s1.b in s2 Base.:(==)(s1::AbstractSet, s2::SetOfTwo) = s2 == s1

В дополнение к этому есть ряд символов Юникода, которые парсер будет интерпретировать как инфиксные функции, если таковые определить. Поэтому при необходимости легко добавить, например, инфиксную запись для логической импликации:

julia> ⇒(a::Bool, b::Bool) = b || !a ⇒ (generic function with 1 method)  julia> struct Торт end  julia> Хабр = Торт()  julia> 2 * 2 == 4 ⇒ Хабр isa Торт true

Префикс ! для отрицания любой функции

Тут всё просто: для любой функции fn, возвращающей логическое значение, !fn — это функция, которая на тех же аргументах возвращает противоположные значения.

julia> filter(!ismissing, [1, missing, missing, 3, 5, 8, missing]) 4-element Array{Union{Missing, Int64},1}:  1  3  5  8

Протокол итерации

В Julia нет Си-подобного цикла for с произвольной инициализацией, условием выхода и операцией при переходе между итерациями. Единственный допустимый синтаксис для цикла for — это for x in collection ... end. Такое поведение кажется не слишком гибким, но на самом деле оно подталкивает к более структурированному подходу к итерации. Дело в том, что для любого типа объектов можно определить функцию iterate(collection[, state]), а цикл for раскрывается примерно в следующее:

for x in collection     ... end     ⇓ let iter = iterate(collection) while !isnothing(iter)     x, state = iter     ...     iter = iterate(collection, state) end

Ожидается, что функция iterate возвращает следующий элемент и следующее состояние итерации или nothing, если коллекция исчерпана.

Прелесть итерации в том, что она используется под капотом в реализации по умолчанию для ряда функций, таких как foreach (применить некоторое действие ко всем элементам коллекции), collect (собрать коллекцию в массив), in (проверить наличие элемента в коллекции) и др. Таким образом, определив функцию итерации, бесплатно получаем кучу всякого добра. Реализация по умолчанию, впрочем, может быть не оптимальной с точки зрения эффективности — та же проверка наличия элемента линейным поиском не всегда будет именно тем, что надо.

Если очень хочется, итераторы можно компоновать, популярные компоновки представлены в Base.Iterators из стандартной библиотеки. Можно делать и более весёлые вещи — например, представить последовательные приближения, генерируемые численным методом, как итерируемую коллекцию. Если этого не хватает, можно поразвлекаться с циклами, реализованными через интерфейс трансдьюсеров.

Comprehensions

julia> [x for x in 1:3] # массив 3-element Array{Int64,1}:   1   2   3  julia> Float64[x^3 for x in 1:10 if iseven(x)] # явно типизированный массив 5-element Array{Float64,1}:     8.0    64.0   216.0   512.0  1000.0  julia> Dict(string(s) => length(s) for s in split("Это я знаю и помню прекрасно")) # словарь Dict{String,Int64} with 6 entries:   "я"         => 1   "помню"     => 5   "знаю"      => 4   "и"         => 1   "прекрасно" => 9   "Это"       => 3

В общем-то, примерно как в Python. Для сложных выражений Python будет поудобнее, но всё же с comprehension’ами явно лучше, чем без них.

Сами comprehension’ы — это итерируемые объекты, поэтому по ним можно проводить редукцию без лишних выделений памяти:

julia> @btime sum([x for x in 1:10])   38.467 ns (1 allocation: 160 bytes) 55  julia> @btime sum(x for x in 1:10)   1.552 ns (0 allocations: 0 bytes) 55

Естественно, всё, что нужно, чтобы коллекция coll работала в выражении вроде x for x in coll, — это определить для её типа функцию iterate. Поистину магическая функция.

Распаковка коллекций в именованные аргументы

Оператор ... может распаковать коллекцию в аргументы функции:

julia> min(1, 2, 3) 1  julia> min([1, 2, 3]) ERROR: MethodError: no method matching min(::Array{Int64,1})   ...  julia> min([1, 2, 3]...) 1

Можно подумать, что аналогично можно распаковывать и словарь для подстановки именованных аргументов. На самом деле ситуация одновременно лучше и хуже. Хуже — в том, что просто так словарь не распакуешь:

julia> range_settings = Dict(:stop => 10, :step => 3) Dict{Symbol,Int64} with 2 entries:   :stop => 10   :step => 3  julia> range(1, range_settings...) ERROR: MethodError: no method matching range(::Int64, ::Pair{Symbol,Int64}, ::Pair{Symbol,Int64})   ...

Лучше — в том, что если всё делать правильно, то распаковывать можно отнюдь не только словари. Правильно — это поставить перед распаковываемой коллекцией точку с запятой, а не просто запятую. Тогда можно распаковать любую коллекцию, состоящую из пар символ-значение:

julia> range_settings = Dict(:stop => 10, :step => 3) Dict{Symbol,Int64} with 2 entries:   :stop => 10   :step => 3  julia> range(1; range_settings...) 1:3:10  julia> range_settings = [:stop => 10, :step => 3] 2-element Array{Pair{Symbol,Int64},1}:  :stop => 10  :step => 3  julia> range(1; range_settings...) 1:3:10  julia> range_settings = Set(range_settings) Set{Pair{Symbol,Int64}} with 2 elements:   :step => 3   :stop => 10  julia> range(1; range_settings...) 1:3:10

Рекомендуемый вариант — использовать именованный кортеж. В этом случае, в отличие от всех предыдущих, аргументы могут быть подставлены на этапе компиляции, если их значения будут известны.

julia> range_settings = (stop = 10, step = 3) (stop = 10, step = 3)  julia> range(1; range_settings...) 1:3:10

Распаковка кортежей в аргументах

Если аргумент функции — это кортеж известной длины, — то в списке аргументов его можно записать как кортеж имён, и обращаться в теле функции к элементам кортежа по этим именам, а не по индексам. Например:

# без распаковки function crossproduct1(p1::NTuple{3, Real}, p2::NTuple{3, Real})     return p1[2]*p2[3] - p1[3]*p2[2], p1[3]*p2[1] - p1[1]*p2[3], p1[1]*p2[2] - p1[2]*p2[1] end  # с распаковкой function crossproduct2((x1, y1, z1)::NTuple{3, Real}, (x2, y2, z2)::NTuple{3, Real})     return y1 * z2 - y2 * z1, z1 * x2 - x1 * z2, x1 * y2 - y1 * x2 end

Broadcast

Дописывание точки после любой функции превращает её в broadcasted-версию, которая к массивам применяется поэлементно, делает объединение циклов (loop fusion), автоматически приводит массивы к одинаковым рангам и т.п.

Какие-то языки умеют делать объединение циклов для частых операций (типа сложения / вычитания, умножения / деления, возведения в степень, тригонометрических операций) и для специфических типов данных. Штука в том, что broadcast позволяет его сделать для любой функции, неважно, встроенная она или определена пользователем. Единственное неудобство — программист должен явно указать, где он хочет применять "векторизованную" версию, а где обычную. На практике это не особо мешает, впрочем. Поскольку весь "векторизованный" синтаксис в конечном счёте является сахаром к выражению broadcast(f, collection), то, перегрузив broadcast под collection конкретного типа, программист получает общий механизм для удобной записи векторизованных операций.

Например, из встроенных типов можно применять broadcast к скалярам, массивам и кортежам. И, конечно, же, можно их мешать в любой комбинации.

julia> parse.(Int, ("3", "14", "15")).^(3, 2, 1) (27, 196, 15)  julia> (x -> x / 5).(parse.(Float64, ["92", "65", "36"])) 3-element Array{Float64,1}:  18.4  13.0   7.2  julia> parse.(Int, ("3", "14", "15")).^(3, 2, 1) .+ (x -> x / 5).(parse.(Float64, ["92", "65", "36"])) 3-element Array{Float64,1}:   45.4  209.0   22.2

Синтаксис do

Формально: выражение внутри do-блока оборачивается в анонимную функцию и передаётся первым аргументом в функцию, которая записана перед ним. То есть запись

foo(args...) do x     do_something end

преобразуется к

foo(x -> do_something, args...)

Что это даёт?

Во-первых, удобную запись анонимных функций для передачи в какой-нибудь map или accumulate:

# было map(x -> begin             a, b, c = x[1], x[2], x[3]             return a - (b + c) / 2, b - (a + c) / 2, c - (a + b) / 2          end,     [A, B, C])  # стало map([A, B, C]) do x     a, b, c = x[1], x[2], x[3]     return a - (b + c) / 2, b - (a + c) / 2, c - (a + b) / 2 end

Во-вторых, легко делать аналог with ... as ... из Python. Например, стандартная функция open может принять первым аргументом функцию, в этом случае функция применяется к открытому файлу:

open(f -> println(readline(f)), "myfile.txt", "r")  # или open("myfile.txt", "r") do io     firstline = readline(io)     println(firstline) end

Благодаря множественной диспетчеризации, функция open перегружена для случая, когда первым аргументом является функция, и гарантирует, что в таком случае файл будет закрыт, когда работа с ним закончена:

function open(f::Function, args...)     io = open(args...)     try         f(io)     finally         close(io)     end end

Кроме удобства написания и читаемости, этот синтаксис добавляет ещё одно соглашение по организации кода — если аргументом метода является функция, то её настоятельно рекомендуется ставить первой в списке аргументов для удобства передачи через do-блок. Это означает, что если вы любите функции высшего порядка и часто ими пользуетесь, вам нужно помнить чуть меньше об их сигнатурах — функциональный аргумент в подавляющем большинстве случаев будет первым, как и рекомендовано.

Надеюсь, статья была полезной, и вы узнали, как можно сделать код менее монотонным и лучше читаемым.