Типы

С помощью оператора :: можно добавлять аннотации типов к выражениям и переменным в коде. Главных причин для этого может быть две:

При добавлении к выражению, предназначенному для вычисления значения, оператор :: означает «является экземпляром типа». Таким образом, он утверждает, что значение выражения в левой части является экземпляром типа в правой. Если тип справа является конкретным, значение слева должно реализовываться этим типом. Напомним, что все конкретные типы являются конечными, поэтому реализация типа не может быть подтипом другой реализации. Если же тип справа является абстрактным, достаточно, чтобы значение реализовывалось конкретным типом, являющимся подтипом этого абстрактного типа. Если утверждение типа не равно true, вызывается исключение; в противном случае возвращается значение выражения слева.

Это позволяет добавлять утверждение типа к любому выражению на месте.

При добавлении к переменной в левой части присваивания или в рамках объявления local оператор :: имеет немного иное значение: он объявляет, что переменная всегда имеет указанный тип, аналогично объявлению типа в языках со статической типизацией, таких как C. Любое значение, присваиваемое переменной, преобразуется в объявленный тип с помощью функции convert.

Такой вариант применения позволяет избежать проблем с производительностью в результате присваивания переменной непредвиденного типа.

Данный вариант (объявление типа) используется только в определенных ситуациях:

и применяется к всей текущей области даже перед объявлением.

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

Объявления также можно применять к определениям функций.

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

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

Как вы помните, в главе Целые числа и числа с плавающей запятой были представлены различные конкретные типы числовых значений: Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Int128, UInt128, Float16, Float32 и Float64. Хотя типы Int8, Int16, Int32, Int64 и Int128 имеют разный размер представления, объединяет их то, что все это целочисленные типы со знаком. В свою очередь, UInt8, UInt16, UInt32, UInt64 и UInt128 — это целочисленные типы без знака, а Float16, Float32 и Float64 — типы с плавающей запятой. Зачастую в определенной части кода может быть важно, чтобы аргументы были, например, некоторыми целыми числами, но неважно, какими именно. Так, алгоритм нахождения наибольшего общего делителя будет работать с любыми целыми числами, но не с числами с плавающей запятой. Абстрактные типы позволяют выстраивать иерархию типов, в которую вписываются конкретные типы. Например, это позволяет легко написать алгоритм, который будет работать с любым целочисленным типом без ограничений.

Абстрактные типы объявляются с помощью ключевого слова abstract type. Стандартные синтаксические конструкции для объявления абстрактного типа выглядят так:

Ключевое слово abstract type вводит новый абстрактный тип с именем «name». После этого имени можно указать <: и какой-либо существующий тип. Это означает, что объявляемый абстрактный тип является подтипом данного родительского типа.

Если супертип не указан, по умолчанию им является Any — предопределенный абстрактный тип, экземплярами которого являются все объекты, а подтипами — все остальные типы. В теории типов тип Any обычно называется высшим, потому что он находится на самой вершине графа типов. В Julia также есть предопределенный абстрактный нижний тип, который находится в низшей точке графа типов. Он записывается как Union{}. Этот тип является прямой противоположностью типу Any: ни один объект не является экземпляром Union{}, и все типы являются супертипами Union{}.

Рассмотрим ряд абстрактных типов, составляющих иерархию числовых типов Julia.

Тип Number является непосредственным потомком типа Any, а Real — его потомок. В свою очередь, у Real есть два потомка (на самом деле их больше, но здесь представлены только два; к остальным мы вернемся позже). Integer и AbstractFloat. Они представляют соответственно целые и вещественные числа. К представлениям вещественных чисел относятся типы с плавающей запятой, но, помимо этого, и другие типы, например рациональные. AbstractFloat включает только представления вещественных чисел с плавающей запятой. Целочисленные типы далее подразделяются на Signed (со знаком) и Unsigned (без знака).

Оператор <: в общем смысле означает «является подтипом» и объявляет, что тип справа является прямым супертипом объявляемого типа. Он также может применяться в качестве оператора подтипа в выражениях, возвращающих true, если левый операнд является подтипом правого.

Важным назначением абстрактных типов является предоставление реализаций по умолчанию для конкретных типов. Вот простой пример.

Во-первых, следует обратить внимание на то, что представленные выше объявления аргументов равносильны x::Any и y::Any. При вызове этой функции, например myplus(2,5), диспетчер выбирает наиболее специфичный метод с именем myplus, соответствующий переданным аргументам. (Дополнительные сведения о множественной диспетчеризации см. в главе Методы.)

Если более специфичный, чем приведенный выше, метод не найден, Julia создает внутреннее определение и компилирует метод с именем myplus для двух аргументов типа Int на основе приведенной выше универсальной функции. То есть неявным образом определяется и компилируется следующий метод.

Наконец, вызывается этот специфичный метод.

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

Важно отметить, что использование функции с аргументами абстрактных типов не сказывается на производительности, потому что функция компилируется повторно для каждого кортежа аргументов конкретных типов, с которыми она вызывается. (Однако проблемы с производительностью возможны, если аргументы функции представляют собой контейнеры абстрактных типов; см. главу Советы по производительности.)

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

Стандартные синтаксические конструкции для объявления примитивного типа выглядят так:

Элемент bits означает, сколько битов нужно для хранения типа, а элемент name определяет имя нового типа. Объявить примитивный тип можно и как подтип какого-либо супертипа. Если супертип не указан, то непосредственным супертипом по умолчанию является Any. Таким образом, приведенное выше объявление Bool означает, что для хранения логического значения нужно восемь битов, а его непосредственным супертипом является тип Integer. В настоящее время поддерживаются только размеры, кратные 8 бит, а при использовании размеров, отличных от перечисленных выше, вероятны ошибки LLVM. Поэтому, хотя для представления логического значения достаточно всего одного бита, его нельзя объявить размером менее 8 бит.

Типы Bool, Int8 и UInt8 имеют идентичные представления в памяти: все они занимают 8 бит. Однако, поскольку система типов Julia является номинативной, несмотря на идентичную структуру, эти типы не взаимозаменяемые. Принципиальное различие между ними в том, что у них разные супертипы: у Bool прямой супертип — Integer, у Int8 — Signed, а у UInt8 — Unsigned. В остальном разница между Bool, Int8 и UInt8 сводится к тому, какое поведение определено для функций при передаче объектов этих типов в качестве аргументов. Вот почему необходима номинативная система типов: если бы структура определяла тип, а он, в свою очередь, диктовал бы поведение, было бы невозможно реализовать для Bool иное поведение, чем для Int8 или UInt8.

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

В популярных объектно ориентированных языках, таких как C++, Java, Python и Ruby, с составными типами также связаны именованные функции: в совокупности это называется объектом. В более чистых объектно ориентированных языках, таких как Ruby или Smalltalk, объектами являются все значения, будь то составные или нет. В менее чистых объектно ориентированных языках, включая C++ и Java, некоторые значения, например целочисленные и с плавающей запятой, не являются объектами. Истинными объектами являются экземпляры пользовательских составных типов со связанными методами. В Julia объектами являются любые значения, но функции не привязаны к объектам, с которыми они производят операции. Обусловлено это тем, что в Julia требуемый метод функции выбирается посредством множественной диспетчеризации, а значит, при выборе метода учитываются типы всех аргументов функции, а не только первого (дополнительные сведения о методах и диспетчеризации см. в главе Методы). Поэтому зависимость функции лишь от первого аргумента была бы неправильной. Организация методов как объектов-функций вместо именованных наборов методов внутри каждого объекта оказывается крайне полезной особенностью устройства языка.

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

Поля без аннотаций типов по умолчанию имеют тип Any и, соответственно, могут содержать значение любого типа.

Новые объекты типа Foo создаются путем применения типа Foo как функции к значениям полей.

Когда тип применяется как функция, он называется конструктором. Два конструктора создаются автоматически (они называются конструкторами по умолчанию). Один из них принимает любые аргументы и вызывает функцию convert для их преобразования в типы полей, а другой принимает аргументы, которые в точности соответствуют типам полей. Оба этих конструктора создаются для того, чтобы было проще добавлять новые определения, не заменив случайно конструктор по умолчанию.

Так как тип поля bar ничем не ограничен, подойдет любое значение. Однако значение baz должно быть таким, чтобы его можно было преобразовать в Int.

Список имен полей можно получить с помощью функции fieldnames.

Обращаться к значениям полей составного объекта можно посредством общепринятой нотации foo.bar.

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

Поля неизменяемого объекта могут содержать изменяемые объекты, например массивы. Такие вложенные объекты остаются изменяемыми: нельзя изменять лишь поля самого неизменяемого объекта так, чтобы они указывали на другие объекты.

При необходимости можно объявлять изменяемые составные объекты с помощью ключевого слова mutable struct. Об этом речь пойдет в следующем разделе.

Если все поля неизменяемой структуры неотличимы друг от друга (===), то два неизменяемых значения с такими полями также неотличимы.

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

Для многих пользовательских типов X может потребоваться определить метод Base.broadcastable(x::X) = Ref(x), чтобы экземпляры типа выступали в качестве 0-мерных «скаляров» в целях трансляции.

Если составной тип объявлен с помощью ключевого слова mutable struct, а не struct, то его экземпляры можно изменять.

Дополнительный интерфейс между полями и пользователем могут обеспечивать свойства экземпляра. Они дают больше контроля над тем, какие элементы будут доступны для просмотра и изменения посредством нотации bar.baz.

Для поддержки изменения такие объекты обычно размещаются в куче и имеют фиксированные адреса памяти. Изменяемый объект похож на небольшой контейнер, который на протяжении своего существования может содержать разные значения и поэтому надежно идентифицируется только по адресу в памяти. Напротив, экземпляр изменяемого типа связан с определенными значениями полей, которыми он полностью описывается. Принимая решение о том, должен ли тип быть изменяемым, отталкивайтесь от того, будут ли два экземпляра с одинаковыми значениями полей считаться идентичными или же они могут изменяться независимо друг от друга с течением времени. Если они будут считаться идентичными, скорее всего, тип должен быть неизменяемым.

Подводя итог, неизменяемость в Julia характеризуется двумя основными качествами.

Если известно, что неизменяемыми являются лишь некоторые поля изменяемой структуры, эти поля можно объявить таковыми с помощью ключевого слова const, как показано ниже. Это обеспечивает ряд оптимизаций неизменяемых структур и позволяет применять инварианты к определенным полям, помеченным как const.

Три категории типов, которые рассматривались в предыдущих разделах (абстрактные, примитивные и составные), на самом деле тесно связаны друг с другом. Они все обладают общими важными свойствами.

Из-за наличия этих общих свойств все данные типы представлены внутренне как экземпляры DataType — типа, к которому относятся все эти типы.

Тип DataType может быть абстрактным или конкретным. Если он конкретный, у него есть определенный размер, схема размещения в памяти и (необязательно) имена полей. Таким образом, примитивный тип представляет собой тип DataType ненулевого размера, но без имен полей. Составной тип — это тип DataType с именами полей или пустой (нулевого размера).

Каждое конкретное значение в системе является экземпляром какого-либо типа DataType.

Объединение типов — это особый абстрактный тип, который включает в себя все экземпляры всех типов-аргументов в качестве объектов. Он создается с помощью специального ключевого слова Union.

В компиляторах многих языков предусмотрена внутренняя конструкция для объединения, позволяющая определять типы; в Julia же она доступна программистам. Компилятор Julia может генерировать эффективный код при наличии объединений Union, включающих небольшое количество типов ^[1]. Для этого для каждого возможного типа генерируется специализированный код в отдельной ветви.

Особо полезным вариантом применения типа Union является Union{T, Nothing}, где T может быть любым типом, а Nothing — это одинарный тип, единственным экземпляром которого является объект nothing. Такой шаблон в Julia — это эквивалент типов Nullable, Option или Maybe в других языках. Если объявить аргумент функции или поле как Union{T, Nothing}, им можно будет присваивать либо значение типа T, либо nothing, что означает отсутствие значения. Дополнительные сведения см. в этом разделе FAQ.

Важной и полезной особенностью системы типов Julia является то, что она параметрическая: типы могут принимать параметры, так что при объявлении типа вводится целое семейство новых типов — по одному для каждой возможной комбинации значений параметров. Во многих языках в той или иной форме поддерживается универсальное программирование, позволяющее определять структуры данных и алгоритмы для работы с ними без точного указания типов. Например, универсальное программирование так или иначе реализовано в ML, Haskell, Ada, Eiffel, C++, Java, C#, F#, Scala и других языках. В некоторых из этих языков (например, в ML, Haskell, Scala) поддерживается истинный параметрический полиморфизм, а в других (например, в C++, Java) — особые стили универсального программирования на основе шаблонов. Вследствие такого разнообразия подходов к универсальному программированию и параметрическим типам мы даже не будем пытаться сравнивать Julia с другими языками в этом плане. Вместо этого мы сосредоточимся на рассмотрении этой системы собственно в Julia. Однако отметим, что многие сложности, характерные для систем статических параметрических типов, можно сравнительно легко преодолеть, поскольку Julia — язык с динамической типизацией, не требующий определения всех типов во время компиляции.

Все объявляемые типы (разновидности DataType) можно параметризировать, используя один и тот же синтаксис. Мы рассмотрим их в следующем порядке: сначала параметрические составные типы, затем параметрические абстрактные типы и, наконец, параметрические примитивные типы.

Мы уже отмечали, что параметрический тип, например Ptr, выступает в роли супертипа для всех своих экземпляров (Ptr{Int64} и т. д.). Как это работает? Сам по себе тип Ptr не может быть обычным типом данных: его нельзя использовать для операций с памятью, если тип соответствующих данных неизвестен. Объяснение заключается в том, что Ptr (или иные параметрические типы, например Array) — это тип особого рода, который называется UnionAll. Такой тип означает итерируемое объединение типов для всех значений некоторого параметра.

Типы UnionAll обычно записываются с использованием ключевого слова where. Например, Ptr можно было бы более точно записать как Ptr{T} where T, что соответствует всем значениям типа Ptr{T} для некоторого значения T. В этом контексте параметр T также часто называют переменной типа, так как он выступает в роли переменной, значениями которой может быть определенный набор типов. Каждое ключевое слово where вводит одну переменную типа, поэтому такие выражения могут быть вложенными для типов с несколькими параметрами, например Array{T,N} where N where T.

Синтаксис применения типа A{B,C} требует, чтобы A было типом UnionAll, и сначала происходит подстановка B во внешнюю переменную типа в A. Результат должен быть другим типом UnionAll, в который затем подставляется C. Таким образом, A{B,C} эквивалентно A{B}{C}. Этим объясняется то, почему возможно частичное создание экземпляра типа, например Array{Float64}: значение первого параметра является фиксированным, но второй по-прежнему принимает все возможные значения. При использовании синтаксиса where явным образом фиксированным может быть любое подмножество параметров. Например, тип всех одномерных массивов можно записать в виде Array{T,1} where T.

Переменные типов можно ограничивать посредством отношений подтипов. Array{T} where T<:Integer означает все массивы с типами элементов, которые являются некоторыми подтипами Integer. Для синтаксической конструкции Array{T} where T<:Integer есть удобная краткая форма записи: Array{<:Integer}. У переменных типов могут быть нижние и верхние границы. Array{T} where Int<:T<:Number означает все массивы элементов Number, которые могут содержать Int (размер T должен быть не менее Int). С помощью синтаксиса where T>:Int также можно указать только нижнюю границу переменной типа, а Array{>:Int} эквивалентно Array{T} where T>:Int.

Так как выражения where могут быть вложенными, границы переменной типа могут относиться к внешним переменным типа. Например, Tuple{T,Array{S}} where S<:AbstractArray{T} where T<:Real означает двухэлементные кортежи, первый элемент которых относится к некоторому подтипу Real, а второй элемент — это любой массив Array, элементы которого относятся к типу первого элемента кортежа.

Само ключевое слово where можно вкладывать в более сложные объявления. Например, рассмотрим два типа, создаваемые посредством следующих объявлений.

Тип T1 определяет одномерный массив одномерных массивов; каждый внутренний массив состоит из объектов одного типа, но эти типы объектов у внутренних массивов могут быть разными. В свою очередь, тип T2 определяет одномерный массив одномерных массивов, в котором объекты всех внутренних массивов относятся к одному и тому же типу. Обратите внимание, что T2 — это абстрактный тип (например, Array{Array{Int,1},1} <: T2), а T1 — конкретный. По этой причине экземпляр T1 можно создать с помощью конструктора без аргументов (a=T1()), а экземпляр T2 нельзя.

Существует удобный синтаксис для именования таких типов, похожий на краткую форму определения функций.

Это эквивалентно const Vector = Array{T,1} where T. Запись Vector{Float64} эквивалентна Array{Float64,1}, причем экземплярами общего типа Vector являются все объекты Array, у которых второй параметр — количество измерений массива — равен 1, независимо от типа элементов. В языках, в которых параметрические типы всегда должны указываться полностью, это не особо полезно, но в Julia благодаря этому можно просто написать Vector, чтобы определить абстрактный тип, включающий все одномерные плотные массивы с элементами любого типа.

Неизменяемые составные типы без полей называются одинарными. Выражаясь формально, если

то T — это одинарный тип.^[2] Проверить, является ли тип одинарным, можно с помощью функции Base.issingletontype. Абстрактные типы по своей природе не могут быть одинарными.

По определению у одинарного типа может быть только один экземпляр.

Функция === подтверждает, что создаваемые экземпляры NoFields тождественны друг другу.

Параметрические типы могут быть одинарными, если выполняется приведенное выше условие. Например,

У каждой функции есть свой тип, который является подтипом Function.

Обратите внимание, что вывод в результате вызова typeof(foo41) аналогичен самому вызову. Это просто соглашение, так как данный объект является вполне самостоятельным и может использоваться как любое другое значение.

Типы функций, определенных на верхнем уровне, являются одинарными. При необходимости их можно сравнивать с помощью оператора ===.

У замыканий также есть собственные типы, имена которых обычно выводятся с #<number> в конце. У функций, определенных в разных местах, уникальные имена и типы, причем вывод от сеанса к сеансу может различаться.

Типы замыканий необязательно являются одинарными.

Для каждого типа T Type{T} — это абстрактный параметрический тип, единственным экземпляром которого является объект T. Пока еще не были рассмотрены параметрические методы и преобразования, назначение этой конструкции объяснить трудно, но, если вкратце, она позволяет специализировать поведение функции для определенных типов как значений. Это полезно для написания методов (особенно параметрических), поведение которых зависит от типа, переданного явным образом в качестве аргумента, а не выводимого из типа одного из аргументов.

Так как это определение может быть немного сложным для понимания, давайте рассмотрим ряд примеров.

Иными словами, isa(A, Type{B}) равно true тогда и только тогда, когда A и B являются одним и тем же объектом и этот объект — тип.

В частности, поскольку параметрические типы инвариантны:

Без параметра Type — это просто абстрактный тип, экземплярами которого являются все объекты типов.

Любой объект, отличный от типа, не является экземпляром Type.

Хотя Type является частью иерархии типов Julia, как и любой другой абстрактный параметрический тип, обычно он не используется вне сигнатур методов, за исключением ряда особых случаев. Еще одно важное применение Type — уточнение типов полей, которые в противном случае были бы менее точными, например DataType в примере ниже. В этом случае конструктор по умолчанию мог бы привести к проблемам с производительностью кода, в котором используется точный тип, заключенный в оболочку (аналогично параметрам абстрактных типов).

Иногда бывает удобно ввести новое имя для уже выразимого типа. Это можно сделать с помощью простого оператора присваивания. Например, псевдонимом для UInt может быть UInt32 или UInt64 в зависимости от размера указателей в системе.

Для этой цели в base/boot.jl служит следующий код.

Безусловно, это зависит от того, для какого типа Int создается псевдоним, но это обязательно должен быть правильный тип: либо Int32, либо Int64.

(Обратите внимание, что, в отличие от Int, Float не является псевдонимом для типа AbstractFloat определенного размера. В отличие от целочисленных регистров, где размер Int соответствует размеру машинного указателя в системе, размеры регистров с плавающей запятой определены в стандарте IEEE-754.)

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

Функция isa проверяет, относится ли объект к определенному типу, и возвращает true или false.

Функция typeof, которая уже использовалась в примерах в данном руководстве, возвращает тип своего аргумента. Поскольку, как уже упоминалось ранее, типы являются объектами, у них у самих есть типы и их можно узнать.

Но что, если повторить эту операцию? К какому типу относится тип типа? Оказывается, что все типы являются составными значениями и, таким образом, имеют тип DataType.

DataType является типом для самого себя.

Еще одной операцией, применимой к некоторым типам, является supertype. Она определяет супертип типа. Однозначно определяемые супертипы есть только у объявленных типов (DataType).

При применении функции supertype к другим объектам типов (или к объектам, не являющимся типами), вызывается исключение MethodError.

Иногда требуется настроить отображение экземпляров типа. Для этого следует перегрузить функцию show. Например, предположим, что мы определили тип для представления комплексных чисел в полярной форме.

Здесь мы добавили пользовательскую функцию-конструктор, которая может принимать аргументы разных типов Real и продвигать их до общего типа (см. главы Конструкторы и Преобразование и продвижение). (Конечно же, нам также пришлось бы определить множество других методов, чтобы тип можно было использовать как Number, например +, *, one, zero, правила продвижения и т. д.) По умолчанию экземпляры этого типа отображаются довольно просто: выводится имя типа и значения полей, например Polar{Float64}(3.0,4.0).

Если бы мы хотели, чтобы вместо этого информация выводилась в виде 3.0 * exp(4.0im), мы бы определили следующий метод для вывода информации в указанный выходной объект io (представляющий файл, терминал, буфер и т. д.; см. раздел Сеть и потоковая передача).

Возможен и более детальный контроль над отображением объектов Polar. В частности, иногда требуется как подробный многострочный формат вывода информации об одном объекте в REPL и других интерактивных средах, так и более краткий однострочный формат для функции print или для отображения объекта в составе другого объекта (например, массива). Хотя по умолчанию в обоих случаях вызывается функция show(io, z), вы можете определить другой многострочный формат для отображения объекта, используя перегрузку функции show с тремя аргументами, где вторым аргументом является тип MIME text/plain (см. раздел Ввод-вывод мультимедийных данных).

(Обратите внимание, что посредством print(..., z) здесь вызывается метод show(io, z) с двумя аргументами.) Результат будет следующим.

Здесь для массива значений Polar по-прежнему используется однострочный вариант show(io, z). Строго говоря, среда REPL вызывает display(z) для отображения результата выполнения строки, что по умолчанию соответствует вызову show(stdout, MIME("text/plain"), z), а он, в свою очередь, соответствует вызову show(stdout, z). Однако вам не следует определять новые методы display, если только вы не определяете новый обработчик для отображения мультимедийных данных (см. раздел Ввод-вывод мультимедийных данных).

Более того, вы также можете определить методы show для других типов MIME, чтобы обеспечить отображение информации об объектах с более сложным форматированием (разметкой HTML, изображениями и т. д.) в средах, которые поддерживают такую возможность (например, IJulia). Например, определить отображение информации об объектах Polar в формате HTML с верхними индексами и курсивным начертанием можно так:

В результате в средах, поддерживающих HTML, информация об объекте Polar будет автоматически отображаться с использованием HTML, однако при желании можно вручную вызвать функцию show для получения выходных данных в формате HTML.

An HTML renderer would display this as: Polar{Float64} complex number: 3.0 e^4.0 i^

Согласно общему правилу, однострочный метод show должен выводить допустимое выражение Julia для создания отображаемого объекта. Если этот метод show содержит инфиксные операторы, например оператор умножения (*) в однострочном методе show для типа Polar выше, он может неправильно анализироваться при выводе в составе другого объекта. Чтобы проиллюстрировать это, возьмем объект выражения (см. раздел Представление программы), который возводит в квадрат определенный экземпляр типа Polar.

Так как оператор ^ имеет приоритет над * (см. раздел Приоритет и ассоциативность операторов), этот вывод неверно представляет выражение a ^ 2, которому должно соответствовать выражение (3.0 * exp(4.0im)) ^ 2. Чтобы решить эту проблему, необходимо создать пользовательский метод для Base.show_unquoted(io::IO, z::Polar, indent::Int, precedence::Int), который будет автоматически вызываться объектом выражения при выводе информации.

Определенный выше метод заключает вызов show в круглые скобки, когда приоритет вызывающего оператора выше приоритета умножения или равен ему. Эта проверка позволяет опускать круглые скобки при выводе выражения, которое правильно анализируется без них (например, :($a + 2) и :($a == 2)).

В некоторых случаях может быть полезно настраивать поведение методов show в зависимости от контекста. Для этого можно использовать тип IOContext, который позволяет передавать контекстные свойства вместе с заключенным в оболочку потоком ввода-вывода. Например, метод show может выдавать более краткое представление, когда свойство :compact имеет значение true, или полное представление, когда это свойство имеет значение false или не задано.

Это новое краткое представление будет использоваться, когда передаваемый поток ввода-вывода представляет собой объект IOContext с заданным свойством :compact. В частности, это будет происходить при выводе массивов с несколькими столбцами (когда ширина ограничена).

В документации по IOContext приведен список часто используемых свойств, которые можно использовать для настройки вывода.

В Julia диспетчеризация по значению, например true или false, невозможна. Однако возможна диспетчеризация по параметрическим типам, причем Julia позволяет включать простые битовые значения (типы, символы, целые числа, числа с плавающей запятой, кортежи и т. д.) в качестве параметров типа. Обычный пример — параметр размерности в Array{T,N}, где T — это тип (например, Float64), но N — это просто Int.

Вы можете создавать собственные пользовательские типы, принимающие значения в качестве параметров, и использовать их для управления диспетчеризацией пользовательских типов. Чтобы проиллюстрировать данную концепцию, введем параметрический тип Val{x} и его конструктор Val(x) = Val{x}(), который позволяет использовать этот прием в случаях, когда более развитая иерархия не требуется.

Val определяется следующим образом:

Реализация Val этим ограничивается. Некоторые функции в стандартной библиотеке Julia принимают экземпляры Val в качестве аргументов, и вы можете использовать этот тип для написания собственных функций. Например:

В целях согласованности в Julia в месте вызова всегда должен передаваться экземпляр Val, а не тип, то есть следует использовать foo(Val(:bar)), а не foo(Val{:bar}).

Стоит отметить, что параметрические типы значений, включая Val, очень легко использовать неправильно и в наихудшем случае производительность кода может существенно снизиться. В частности, никогда не стоит писать код так, как показано выше. Дополнительные сведения о надлежащих (и ненадлежащих) вариантах применения Val см. в советах по производительности.