Конструкторы

Конструкторы [1] — это функции, которые создают новые объекты — конкретно, экземпляры Составных типов. В Julia объекты типов также служат функциями-конструкторами: они создают новые экземпляры самих себя при применении к кортежу аргументов как функция. Это уже кратко упоминалось при введении составных типов. Например:

julia> struct Foo
           bar
           baz
       end

julia> foo = Foo(1, 2)
Foo(1, 2)

julia> foo.bar
1

julia> foo.baz
2

Для многих типов создание новых объектов путём связывания значений их полей — всё, что необходимо для создания экземпляров. Однако в некоторых случаях для создания составных объектов требуется больше функциональности. Иногда необходимо обеспечить соблюдение инвариантов, либо проверяя аргументы, либо преобразовывая их. Рекурсивные структуры данных, особенно те, которые могут быть самоссылочными, часто нельзя создать надёжно без предварительного создания в неполном состоянии, а затем программной модификации для завершения, как отдельного шага от создания объекта. Иногда просто удобно создавать объекты с меньшим или другим типом параметров, чем у них полей. Система Julia для создания объектов решает все эти и другие случаи.

Внешние методы конструкторов

Конструктор — это такая же функция в Julia, как и любая другая, поведение которой определяется объединённым поведением его методов. Соответственно, вы можете добавить функциональность конструктору, просто определив новые методы. Например, предположим, что вы хотите добавить метод конструктора для Foo объектов, принимающий только один аргумент и использующий данное значение для обоих полей bar и baz. Это просто:

julia> Foo(x) = Foo(x,x)
Foo

julia> Foo(1)
Foo(1, 1)

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

julia> Foo() = Foo(0)
Foo

julia> Foo()
Foo(0, 0)

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

Внутренние методы конструкторов

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

1. Он объявляется внутри блока объявления типа, а не вне его, как обычные методы.
2. Он имеет доступ к специальной локальной функции с именем new, которая создаёт объекты типа блока.

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

julia> struct OrderedPair
           x::Real
           y::Real
           OrderedPair(x,y) = x > y ? error("out of order") : new(x,y)
       end

Теперь объекты OrderedPair могут быть созданы только таким образом, чтобы x <= y:

julia> OrderedPair(1, 2)
OrderedPair(1, 2)

julia> OrderedPair(2,1)
ERROR: out of order
Stacktrace:
 [1] error at ./error.jl:33 [inlined]
 [2] OrderedPair(::Int64, ::Int64) at ./none:4
 [3] top-level scope

Если тип был объявлен mutable, вы могли бы напрямую изменить значения полей, чтобы нарушить этот инвариант. Конечно, вмешательство в внутренние свойства объекта без приглашения — плохая практика. Вы (или кто-то другой) также можете предоставить дополнительные внешние методы конструкторов в любой момент позже, но после объявления типа нет способа добавить больше внутренних методов конструкторов. Поскольку внешние методы конструкторов могут создавать объекты только вызывая другие методы конструкторов, в конечном итоге должен быть вызван какой-то внутренний конструктор для создания объекта. Это гарантирует, что все объекты объявленного типа должны быть созданы путём вызова одного из внутренних методов конструкторов, предоставленных с типом, тем самым обеспечивая определённую степень соблюдения инвариантов типа.

Если определён какой-либо внутренний метод конструктора, метод конструктора по умолчанию не предоставляется: предполагается, что вы сами предоставили все необходимые вам внутренние конструкторы. Конструктор по умолчанию эквивалентен написанию собственного внутреннего метода конструктора, который принимает все поля объекта в качестве параметров (при условии, что они имеют правильный тип, если соответствующее поле имеет тип), и передаёт их в new, возвращая полученный объект:

julia> struct Foo
           bar
           baz
           Foo(bar,baz) = new(bar,baz)
       end

Это объявление имеет тот же эффект, что и предыдущее определение типа Foo без явного внутреннего метода конструктора. Следующие два типа эквивалентны — один с конструктором по умолчанию, другой с явным конструктором:

julia> struct T1
           x::Int64
       end

julia> struct T2
           x::Int64
           T2(x) = new(x)
       end

julia> T1(1)
T1(1)

julia> T2(1)
T2(1)

julia> T1(1.0)
T1(1)

julia> T2(1.0)
T2(1)

Хорошей практикой является предоставление как можно меньшего количества внутренних методов конструкторов: только тех, которые явно принимают все аргументы и обеспечивают необходимую проверку ошибок и преобразование. Дополнительные удобные методы конструкторов, предоставляющие значения по умолчанию или вспомогательные преобразования, следует предоставлять как внешние конструкторы, которые вызывают внутренние конструкторы для выполнения основной работы. Это разделение обычно довольно естественно.

Неполная инициализация

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

julia> mutable struct SelfReferential
           obj::SelfReferential
       end

Этот тип может показаться достаточно безобидным, пока не подумаешь о том, как создать его экземпляр. Если a является экземпляром SelfReferential, то второй экземпляр можно создать вызовом:

julia> b = SelfReferential(a)

Но как создать первый экземпляр, когда ни один экземпляр не существует, чтобы предоставить его в качестве действительного значения для его поля obj? Единственное решение — разрешить создание неполностью инициализированного экземпляра SelfReferential с неопределённым полем obj, и использовать этот неполный экземпляр как действительное значение для поля obj другого экземпляра, например, самого себя.

Для того чтобы разрешить создание неполностью инициализированных объектов, Julia позволяет вызывать функцию new с меньшим количеством полей, чем у типа, возвращая объект с неинициализированными неопределёнными полями. Внутренний метод конструктора может затем использовать неполный объект, завершая его инициализацию перед возвратом. Вот, например, ещё одна попытка определить тип SelfReferential, на этот раз с использованием внутреннего конструктора без аргументов, возвращающего экземпляры, имеющие поля obj, указывающие на себя:

julia> mutable struct SelfReferential
           obj::SelfReferential
           SelfReferential() = (x = new(); x.obj = x)
       end

Мы можем проверить, что этот конструктор работает и создаёт объекты, которые действительно самоссылочные:

julia> x = SelfReferential();

julia> x === x
true

julia> x === x.obj
true

julia> x === x.obj.obj
true

Хотя обычно рекомендуется возвращать полностью инициализированный объект из внутреннего конструктора, можно вернуть неполностью инициализированные объекты:

julia> mutable struct Incomplete
           data
           Incomplete() = new()
       end

julia> z = Incomplete();

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

julia> z.data
ERROR: UndefRefError: access to undefined reference

Это позволяет избежать необходимости постоянной проверки на значения null. Однако не все поля объекта являются ссылками. Julia рассматривает некоторые типы как «простые данные», то есть все их данные самодостаточны и не ссылаются на другие объекты. Простые типы данных состоят из примитивных типов (например, Int) и неизменяемых структур других простых типов данных. Начальное содержимое простого типа данных не определено:

julia> struct HasPlain
           n::Int
           HasPlain() = new()
       end

julia> HasPlain()
HasPlain(438103441441)

Массивы простых типов данных ведут себя аналогично.

Вы можете передавать неполные объекты в другие функции из внутренних конструкторов, чтобы делегировать их завершение:

julia> mutable struct Lazy
           data
           Lazy(v) = complete_me(new(), v)
       end

Как и с неполными объектами, возвращаемыми от конструкторов, если complete_me или любые его вызывающие функции попытаются получить доступ к полю data объекта Lazy до его инициализации, будет немедленно выброшено исключение.

Параметрические конструкторы

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

julia> struct Point{T<:Real}
           x::T
           y::T
       end

julia> Point(1,2) ## implicit T ##
Point{Int64}(1, 2)

julia> Point(1.0,2.5) ## implicit T ##
Point{Float64}(1.0, 2.5)

julia> Point(1,2.5) ## implicit T ##
ERROR: MethodError: no method matching Point(::Int64, ::Float64)
Closest candidates are:
  Point(::T, ::T) where T<:Real at none:2

julia> Point{Int64}(1, 2) ## explicit T ##
Point{Int64}(1, 2)

julia> Point{Int64}(1.0,2.5) ## explicit T ##
ERROR: InexactError: Int64(2.5)
Stacktrace:
[...]

julia> Point{Float64}(1.0, 2.5) ## explicit T ##
Point{Float64}(1.0, 2.5)

julia> Point{Float64}(1,2) ## explicit T ##
Point{Float64}(1.0, 2.0)

Как вы можете видеть, для вызовов конструкторов с явными параметрами типа аргументы преобразуются в подразумеваемые типы полей: Point{Int64}(1,2) работает, но Point{Int64}(1.0,2.5) вызывает InexactError при преобразовании 2.5 в Int64. Когда тип подразумевается аргументами вызова конструктора, как в Point(1,2), типы аргументов должны совпадать — в противном случае T не может быть определён — но любая пара действительных аргументов с совпадающим типом может быть передана в обобщённый конструктор Point.

На самом деле, Point, Point{Float64} и Point{Int64} — это разные функции конструкторов. Фактически, Point{T} — это отдельная функция конструктора для каждого типа T. Без явно предоставленных внутренних конструкторов объявление составного типа Point{T<:Real} автоматически предоставляет внутренний конструктор Point{T} для каждого возможного типа T<:Real, который работает точно так же, как и непараметрические внутренние конструкторы по умолчанию. Он также предоставляет единственный общий внешний Point конструктор, который принимает пары действительных аргументов, которые должны быть одного типа. Это автоматическое предоставление конструкторов эквивалентно следующему явному объявлению:

julia> struct Point{T<:Real}
           x::T
           y::T
           Point{T}(x,y) where {T<:Real} = new(x,y)
       end

julia> Point(x::T, y::T) where {T<:Real} = Point{T}(x,y);

Обратите внимание, что каждое определение выглядит как форма вызова конструктора, который оно обрабатывает. Вызов Point{Int64}(1,2) вызовет определение Point{T}(x,y) внутри блока struct. С другой стороны, объявление внешнего конструктора определяет метод для общего конструктора Point, который применяется только к парам значений одного и того же вещественного типа. Это объявление позволяет конструкторам вызываться без явных параметров типа, например, Point(1,2) и Point(1.0,2.5), работать. Поскольку объявление метода ограничивает аргументы одним типом, вызовы, такие как Point(1,2.5), с аргументами разных типов, приводят к ошибкам "метод не найден".

Предположим, что мы хотели заставить конструктор вызов Point(1,2.5) работать, "преобразуя" целое значение 1 в значение с плавающей запятой 1.0. Самый простой способ достижения этого — определить следующий дополнительный метод внешнего конструктора:

julia> Point(x::Int64, y::Float64) = Point(convert(Float64,x),y);

Этот метод использует функцию convert, чтобы явно преобразовать x в Float64, а затем делегирует построение общему конструктору в случае, когда оба аргумента являются Float64. С этим определением метода то, что ранее было ошибкой MethodError, теперь успешно создаёт точку типа Point{Float64}:

julia> Point(1,2.5)
Point{Float64}(1.0, 2.5)

julia> typeof(ans)
Point{Float64}

Однако другие аналогичные вызовы по-прежнему не работают:

julia> Point(1.5,2)
ERROR: MethodError: no method matching Point(::Float64, ::Int64)
Closest candidates are:
  Point(::T, !Matched::T) where T<:Real at none:1

Для более общего способа разумного обработки всех таких вызовов см. Преобразование и продвижение. Рискуя испортить интригу, мы можем раскрыть, что всё, что нужно, это следующее определение внешнего метода, чтобы все вызовы общего конструктора Point работали так, как ожидается:

julia> Point(x::Real, y::Real) = Point(promote(x,y)...);

Функция promote преобразует все свои аргументы в общий тип — в данном случае Float64. С этим определением метода конструктор Point продвигает свои аргументы так же, как и числовые операторы, такие как +, и работает для всех видов вещественных чисел:

julia> Point(1.5,2)
Point{Float64}(1.5, 2.0)

julia> Point(1,1//2)
Point{Rational{Int64}}(1//1, 1//2)

julia> Point(1.0,1//2)
Point{Float64}(1.0, 0.5)

Таким образом, хотя конструкторы с неявными параметрами типа, предоставляемые по умолчанию в Julia, достаточно строгие, вполне возможно сделать их поведение более гибким и разумным довольно легко. Кроме того, поскольку конструкторы могут использовать всю мощь системы типов, методов и множественного диспетчеризации, определение сложного поведения обычно довольно просто.

Случайное исследование: Rational

Возможно, лучший способ связать все эти части — представить реальный пример параметрического составного типа и его методов конструкторов. Для этого мы реализуем собственный тип рациональных чисел OurRational, аналогичный встроенному типу Julia Rational, определённому в rational.jl:

julia> struct OurRational{T<:Integer} <: Real
           num::T
           den::T
           function OurRational{T}(num::T, den::T) where T<:Integer
               if num == 0 && den == 0
                    error("invalid rational: 0//0")
               end
               g = gcd(den, num)
               num = div(num, g)
               den = div(den, g)
               new(num, den)
           end
       end

julia> OurRational(n::T, d::T) where {T<:Integer} = OurRational{T}(n,d)
OurRational

julia> OurRational(n::Integer, d::Integer) = OurRational(promote(n,d)...)
OurRational

julia> OurRational(n::Integer) = OurRational(n,one(n))
OurRational

julia> ⊘(n::Integer, d::Integer) = OurRational(n,d)
⊘ (generic function with 1 method)

julia> ⊘(x::OurRational, y::Integer) = x.num ⊘ (x.den*y)
⊘ (generic function with 2 methods)

julia> ⊘(x::Integer, y::OurRational) = (x*y.den) ⊘ y.num
⊘ (generic function with 3 methods)

julia> ⊘(x::Complex, y::Real) = complex(real(x) ⊘ y, imag(x) ⊘ y)
⊘ (generic function with 4 methods)

julia> ⊘(x::Real, y::Complex) = (x*y') ⊘ real(y*y')
⊘ (generic function with 5 methods)

julia> function ⊘(x::Complex, y::Complex)
           xy = x*y'
           yy = real(y*y')
           complex(real(xy) ⊘ yy, imag(xy) ⊘ yy)
       end
⊘ (generic function with 6 methods)

Первая строка — struct OurRational{T<:Integer} <: Real — объявляет, что OurRational принимает один параметр типа целочисленного типа и сам является вещественным типом. Объявления полей num::T и den::T указывают, что данные, хранящиеся в объекте OurRational{T} — это пара целых чисел типа T, одна из которых представляет собой числитель рационального значения, а другая — его знаменатель.

Теперь становится интересно. OurRational имеет единственный внутренний метод конструктора, который проверяет, что ни num, ни den не равны нулю, и гарантирует, что каждый рациональное число строится в "самой низкой форме" со знаменателем неотрицательным. Это достигается путём деления заданных значений числителя и знаменателя на их наибольший общий делитель, вычисленный с помощью функции gcd. Поскольку gcd возвращает наибольший общий делитель своих аргументов со знаком, соответствующим первому аргументу (den здесь), после этого деления новое значение den гарантированно будет неотрицательным. Поскольку это единственный внутренний конструктор для OurRational, мы можем быть уверены, что объекты OurRational всегда строятся в этой нормализованной форме.

OurRational также предоставляет несколько внешних методов конструкторов для удобства. Первый — это "стандартный" общий конструктор, который определяет параметр типа T из типа числителя и знаменателя, когда они имеют один и тот же тип. Второй применяется, когда заданные значения числителя и знаменателя имеют разные типы: он продвигает их до общего типа и затем делегирует построение внешнему конструктору для аргументов с одинаковым типом. Третий внешний конструктор преобразует целые значения в рациональные, предоставив значение 1 в качестве знаменателя.

После определений внешних конструкторов мы определили ряд методов для оператора ⊘, который предоставляет синтаксис для записи рациональных чисел (например, 1 ⊘ 2). Тип Julia Rational использует оператор // для этой цели. До этих определений ⊘ — это совершенно неопределённый оператор с синтаксисом, но без смысла. После этого он ведёт себя так, как описано в Рациональные числа — всё его поведение определено в этих немногих строках. Первое и самое основное определение просто заставляет a ⊘ b построить OurRational, применяя конструктор OurRational к a и b, когда они являются целыми числами. Когда один из операндов ⊘ уже является рациональным числом, мы строим новое рациональное значение для полученного отношения немного иначе; это поведение фактически идентично делению рационального числа на целое число. Наконец, применение ⊘ к комплексным целочисленным значениям создаёт экземпляр Complex{OurRational} — комплексное число, чьи вещественная и мнимая части являются рациональными числами:

julia> z = (1 + 2im) ⊘ (1 - 2im);

julia> typeof(z)
Complex{OurRational{Int64}}

julia> typeof(z) <: Complex{OurRational}
false

Таким образом, хотя оператор ⊘ обычно возвращает экземпляр OurRational, если любой из его аргументов являются комплексными целыми числами, он вернёт экземпляр Complex{OurRational} вместо этого. Заинтересованный читатель должен рассмотреть возможность ознакомления с остальной частью rational.jl: она короткая, самодостаточная и реализует весь базовый тип Julia.

Конструкторы только внешнего уровня

Как мы видели, типичный параметризованный тип имеет внутренние конструкторы, которые вызываются, когда параметры типа известны; например, они применяются к Point{Int} , но не к Point . Можно добавить внешние конструкторы, автоматически определяющие параметры типа, например, для построения Point{Int} из вызова Point(1,2) . Внешние конструкторы вызывают внутренние конструкторы для фактического создания экземпляров. Однако в некоторых случаях желательно не предоставлять внутренние конструкторы, чтобы конкретные параметры типа не могли быть запрошены вручную.

Например, предположим, что мы определяем тип, который хранит вектор вместе с точным представлением его суммы:

julia> struct SummedArray{T<:Number,S<:Number}
           data::Vector{T}
           sum::S
       end

julia> SummedArray(Int32[1; 2; 3], Int32(6))
SummedArray{Int32,Int32}(Int32[1, 2, 3], 6)

Проблема в том, что мы хотим, чтобы S был типом большего размера, чем T, чтобы мы могли суммировать много элементов с меньшей потерей информации. Например, когда T является Int32, мы хотим, чтобы S был Int64. Поэтому мы хотим избежать интерфейса, который позволяет пользователю строить экземпляры типа SummedArray{Int32,Int32}. Один из способов сделать это — предоставить конструктор только для SummedArray, но внутри блока определения struct для подавления генерации конструкторов по умолчанию:

julia> struct SummedArray{T<:Number,S<:Number}
           data::Vector{T}
           sum::S
           function SummedArray(a::Vector{T}) where T
               S = widen(T)
               new{T,S}(a, sum(S, a))
           end
       end

julia> SummedArray(Int32[1; 2; 3], Int32(6))
ERROR: MethodError: no method matching SummedArray(::Array{Int32,1}, ::Int32)
Closest candidates are:
  SummedArray(::Array{T,1}) where T at none:5

Этот конструктор будет вызван синтаксисом SummedArray(a). Синтаксис new{T,S} позволяет указать параметры для строящегося типа, т.е. этот вызов вернёт SummedArray{T,S}. new{T,S} может использоваться в любом определении конструктора, но для удобства параметры для new{} автоматически выводятся из строящегося типа, когда это возможно.