В этой статье я хочу рассказать про вкусные и полезные синтаксические плюшки 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
endBroadcast
Дописывание точки после любой функции превращает её в 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-блок. Это означает, что если вы любите функции высшего порядка и часто ими пользуетесь, вам нужно помнить чуть меньше об их сигнатурах — функциональный аргумент в подавляющем большинстве случаев будет первым, как и рекомендовано.
Надеюсь, статья была полезной, и вы узнали, как можно сделать код менее монотонным и лучше читаемым.
Автор: Василий Писарев
