Основные объекты

# Base.exit — Function

Останавливает программу и возвращает код выхода. Код выхода по умолчанию равен нулю. Это означает, что выполнение программы завершилось успешно. Во время интерактивного сеанса функцию exit() можно вызвать сочетанием клавиш ^D.

# Base.atexit — Function

Регистрирует функцию f() без аргументов или с одним аргументом, вызываемую при выходе из процесса. Перехватчики atexit() вызываются в порядке LIFO (последним поступил — первым обслужен) и выполняются перед финализаторами объектов.

Если f имеет метод, определенный для одного целочисленного аргумента, она будет вызвана как f(n::Int32), где n — это текущий код выхода, иначе она будет вызвана что и у f().

Перехватчики выхода могут вызывать exit(n). В этом случае Julia завершает выполнение с кодом выхода n (вместо изначального кода выхода). Если функцию exit(n) вызывают несколько перехватчиков выхода, Julia завершает выполнение с кодом выхода, соответствующим последнему перехватчику выхода, который вызвал exit(n). (Так как перехватчики выхода вызываются в порядке LIFO, последним вызвавшим будет первый зарегистрированный перехватчик.)

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

# Base.isinteractive — Function

Определяет, выполняется ли интерактивный сеанс Julia.

# Base.summarysize — Function

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

Именованные аргументы

См. также описание sizeof.

Примеры

# Base.__precompile__ — Function

Определяет, можно ли предварительно скомпилировать файл, вызывающий эту функцию. Значение по умолчанию — true. Если предварительная компиляция модуля или файла небезопасна, следует вызвать __precompile__(false), чтобы при попытке предварительной компиляции в Julia возникала ошибка.

# Base.include — Function

Вычисляет содержимое входного файла исходного кода в глобальной области модуля m. У каждого модуля (кроме объявленных с ключевым словом baremodule) есть собственное определение функции include без аргумента m, которое вычисляет содержимое файла в этом модуле. Возвращает результат последнего вычисленного выражения во входном файле. Во время включения в качестве локального для задачи пути включения задается путь к каталогу, содержащему файл. При вложенных вызовах функции include поиск осуществляется относительно этого пути. Эта функция обычно применяется для загрузки исходного кода в интерактивном режиме или для объединения файлов в пакетах, которые разбиты на несколько файлов исходного кода.

С помощью необязательного первого аргумента mapexpr можно преобразовать включаемый код перед его вычислением: для каждого анализируемого выражения expr в path функция include фактически вычисляет mapexpr(expr). Если аргумент mapexpr не указан, по умолчанию он равен identity.

# Base.MainInclude.include — Function

Вычисляет содержимое входного файла исходного кода в глобальной области содержащего модуля. У каждого модуля (кроме объявленных с ключевым словом baremodule) есть собственное определение функции include, которое вычисляет содержимое файла в этом модуле. Возвращает результат последнего вычисленного выражения во входном файле. Во время включения в качестве локального для задачи пути включения задается путь к каталогу, содержащему файл. При вложенных вызовах функции include поиск осуществляется относительно этого пути. Эта функция обычно применяется для загрузки исходного кода в интерактивном режиме или для объединения файлов в пакетах, которые разбиты на несколько файлов исходного кода. Аргумент path нормализуется с помощью функции normpath, которая разрешает символы относительного пути, такие как .., и преобразовывает / в соответствующий разделитель пути.

С помощью необязательного первого аргумента mapexpr можно преобразовать включаемый код перед его вычислением: для каждого анализируемого выражения expr в path функция include фактически вычисляет mapexpr(expr). Если аргумент mapexpr не указан, по умолчанию он равен identity.

Для вычисления содержимого файла в другом модуле используйте Base.include.

# Base.include_string — Function

Действует так же, как include, но считывает код из указанной строки, а не из файла.

С помощью необязательного первого аргумента mapexpr можно преобразовать включаемый код перед его вычислением: для каждого анализируемого выражения expr в code функция include_string фактически вычисляет mapexpr(expr). Если аргумент mapexpr не указан, по умолчанию он равен identity.

# Base.include_dependency — Function

В модуле объявляет, что файл, каталог или символьная ссылка, указанные в аргументе path (в виде относительного или абсолютного), являются зависимостью для предварительной компиляции. Это означает, что модуль потребуется перекомпилировать, если изменится время модификации path.

Требуется только в том случае, если модуль зависит от пути, который не используется посредством include. Действует только при компиляции.

# __init__ — Keyword

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

Примеры

# Base.which — Method

Возвращает метод аргумента f (объект Method), который будет вызываться для аргументов типов types.

Если types — абстрактный тип, возвращается метод, который будет вызываться функцией invoke.

См. также описание функции parentmodule и макросов @which и @edit в модуле InteractiveUtils.

# Base.methods — Function

Возвращает таблицу методов для f.

Если указан аргумент types, возвращает массив методов соответствующих типов. Если указан аргумент module, возвращает массив методов, определенных в этом модуле. Можно также указать список модулей в виде массива.

См. также описание метода which и макроса @which.

# Base.@show — Macro

Выводит одно или несколько выражений с результатами в stdout и возвращает последний результат.

См. также описание show, @info, println.

Примеры

# ans — Keyword

Переменная, ссылающаяся на последнее вычисленное значение, автоматически заданное в интерактивной командной строке.

# Base.active_project — Function

Возвращает путь к активному файлу Project.toml. См. также описание Base.set_active_project.

# Base.set_active_project — Function

Устанавливает файл, указанный в projfile, в качестве активного файла Project.toml. См. также описание Base.active_project.

# module — Keyword

Ключевое слово module объявляет объект Module (модуль) — отдельную глобальную рабочую область переменных. Внутри модуля можно делать видимыми имена из других модулей (путем импорта) или делать имена из данного модуля общедоступными (путем экспорта). Модули позволяют создавать определения верхнего уровня, не беспокоясь о конфликте имен, когда ваш код используется вместе с чьим-то еще. Дополнительные сведения см. в разделе руководства, посвященном модулям.

Примеры

# export — Keyword

Ключевое слово export в модулях сообщает Julia, какие функции должны быть доступны пользователю. Например: export foo делает имя foo доступным при загрузке модуля командой using. Подробные сведения см. в разделе руководства, посвященном модулям.

# import — Keyword

import Foo загружает модуль или пакет Foo. Доступ к именам из импортированного модуля Foo осуществляется через точечную нотацию (например, Foo.foo для доступа к имени foo). Подробные сведения см. в разделе руководства, посвященном модулям.

# using — Keyword

using Foo загружает модуль или пакет Foo и делает его имена, экспортированные с помощью ключевого слова export, доступными для использования напрямую. К именам также можно обращаться через точечную нотацию (например, Foo.foo для доступа к имени foo) независимо от того, экспортированы ли они с помощью export. Подробные сведения см. в разделе руководства, посвященном модулям.

# baremodule — Keyword

baremodule объявляет модуль, который не содержит команду using Base или локальных определений eval и include. Тем не менее модуль Core импортируется. Иными словами,

эквивалентно

# function — Keyword

Функции определяются с помощью ключевого слова function:

Сокращенная запись:

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

# macro — Keyword

Ключевое слово macro определяет метод для вставки сформированного кода в программу. Макрос сопоставляет последовательность выражений, переданных в качестве аргументов, с возвращаемым выражением. Результирующее выражение подставляется в программу в месте вызова макроса. Макросы позволяют выполнять сформированный код, не вызывая eval: сформированный код просто становится частью окружающей программы. Аргументами макроса могут быть выражения, литеральные значения и символы. Макросы можно определять с переменным количеством аргументов (varargs), но они не принимают именованные аргументы. В каждый макрос также неявно передаются аргумент __source__, содержащий номер строки и имя файла, откуда вызывается макрос, и аргумент __module__, содержащий модуль, в котором расширяется макрос.

Дополнительные сведения о написании макросов см. в разделе руководства, посвященном метапрограммированию.

Примеры

# return — Keyword

Оператор return x вызывает досрочный выход из функции с передачей значения x вызывающему объекту. Ключевое слово return без значения эквивалентно return nothing (см. описание константы nothing).

Как правило, оператор return можно помещать в любом месте в теле функции, в том числе в глубоко вложенных циклах или условных операторах, но будьте осторожны с блоками do. Например:

В первом примере оператор return завершает выполнение функции test1, как только встречается четное число, поэтому вызов test1([5,6,7]) возвращает 12.

Во втором примере можно было бы ожидать того же самого, но на самом деле оператор return в этом случае осуществляет выход из внутренней функции (внутри блока do) и возвращает значение функции map. Поэтому вызов test2([5,6,7]) возвращает [5,12,7].

При использовании в выражении верхнего уровня (то есть вне функции) оператор return вызывает досрочное завершение всего текущего выражения верхнего уровня.

# do — Keyword

Создает анонимную функцию и передает ее в качестве первого аргумента в вызов функции. Например:

эквивалентно map(x->2x, 1:10).

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

# begin — Keyword

Ключевые слова begin...end обозначают блок кода.

В begin обычно нет необходимости, потому что такие ключевые слова, как function и let, подразумевают начало блока кода. См. также описание ;.

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

Примеры

# end — Keyword

Ключевое слово end указывает на завершение блока выражений, например module, struct, mutable struct, begin, let, for и т. д.

Ключевое слово end также может использоваться при индексации. В этом случае оно означает последний индекс коллекции или измерения массива.

Примеры

# let — Keyword

Блоки let создают строгую область и дополнительно вводят новые локальные привязки.

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

Переменные, представленные в этой строке, являются локальными для блока let, и присваивания вычисляются по порядку, причем каждая правая часть вычисляется в пределах области без учета имени в левой части. По этой причине выражение let x = x будет иметь смысл, так как две переменные x различны, причем левая часть локально затеняет x из внешней области. Это может быть даже полезным, поскольку новые локальные переменные создаются заново при каждом входе в локальные области, но это проявляется только в том случае, если переменные продолжают существовать за пределами своей области вследствие замыканий.

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

Примеры

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

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

Все конструкции области, которые вводят новые локальные переменные, ведут себя подобным образом при многократном запуске. Отличительной особенностью let является его способность лаконично объявлять новые локальные переменные (local), которые могут затенять внешние переменные с тем же именем. Например, прямое использование аргумента функции do аналогичным образом записывает три разные переменные:

# if — Keyword

Конструкция if/elseif/else позволяет выполнять условные вычисления: части кода вычисляются или не вычисляются в зависимости от значения логического выражения. Синтаксис условной конструкции if/elseif/else устроен следующим образом.

Если выражение условия x < y имеет значение true, то соответствующий блок вычисляется; в противном случае вычисляется выражение условия x > y, и если оно равно true, вычисляется соответствующий блок. Если ни одно из выражений не равно true, вычисляется блок else . Блоки elseif и else являются необязательными. Блоков elseif может быть сколько угодно.

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

# for — Keyword

Цикл for позволяет повторно вычислять блок операторов с итерацией по последовательности значений.

Переменная итерации — это всегда новая переменная, даже если переменная с таким именем уже существует во внешней области. Используйте outer для повторного применения существующей локальной переменной для итерации.

Примеры

# while — Keyword

Цикл while позволяет повторно вычислять условное выражение и продолжать вычислять тело цикла while до тех пор, пока выражение равно true. Если условное выражение равно false при первом вычислении, тело цикла while никогда не вычисляется.

Примеры

# break — Keyword

Осуществляет немедленный выход из цикла.

Примеры

# continue — Keyword

Пропускает оставшуюся часть текущей итерации цикла.

Примеры

# try — Keyword

Оператор try/catch позволяет перехватывать ошибки (исключения), вызываемые функцией throw, чтобы выполнение программы могло продолжаться. Например, в следующем коде производится попытка записи в файл, но пользователь получает предупреждение и выполнение продолжается, если запись в файл невозможна:

или если файл невозможно считать в переменную:

С помощью синтаксиса catch e (где e — любая переменная) объект вызванного исключения присваивается указанной переменной в блоке catch.

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

# finally — Keyword

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

Когда управление передается из блока try (например, вследствие выполнения оператора return или из-за обычного завершения), выполняется функция close(f). Если выход из блока try произойдет вследствие исключения, это исключение будет передано далее. Блок catch также можно использовать в сочетании с try и finally. В этом случае блок finally будет выполнен после того, как блок catch обработает ошибку.

# quote — Keyword

Ключевое слово quote создает несколько объектов выражений на основе блока кода без явного использования конструктора Expr. Например:

В отличие от другого способа цитирования, :( ... ), этот способ добавляет в дерево выражений элементы QuoteNode, которые должны обрабатываться при операциях с деревом. Во всех остальных случаях блоки :( ... ) и quote .. end равноценны.

# local — Keyword

Ключевое слово local объявляет новую локальную переменную. Дополнительные сведения см. в разделе руководства, посвященном областям переменных.

Примеры

# global — Keyword

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

Примеры

# outer — Keyword

Повторно использует существующую локальную переменную для итерации в цикле for.

Дополнительные сведения см. в разделе руководства, посвященном областям переменных.

См. также описание for.

Примеры

# const — Keyword

Ключевое слово const служит для объявления глобальных переменных, значения которых меняться не будут. Практически всегда (и особенно в коде, требовательном к производительности) глобальные переменные должны объявляться константами таким способом.

В одном выражении const можно объявить несколько переменных:

Обратите внимание, что const применяется только к одной операции =, поэтому выражение const x = y = 1 объявляет константой только переменную x, но не y. В свою очередь, выражение const x = const y = 1 объявляет константами как x, так и y.

Обратите внимание на то, что «константность» не распространяется на изменяемые контейнеры; неизменяемой является только связь между переменной и ее значением. Например, если x — это массив или словарь, его элементы можно по-прежнему изменять, добавлять или удалять.

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

# struct — Keyword

Самый широко применяемый тип в Julia — структура. Ее определение состоит из имени и набора полей.

Поля могут иметь ограничения типов, которые могут быть параметризованы:

В структуре также может быть объявлен абстрактный супертип с помощью синтаксиса <::

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

В разделе руководства, посвященном составным типам, приводятся дополнительные сведения, например об определении конструкторов.

# mutable struct — Keyword

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

# Base.@kwdef — Macro

Это вспомогательный макрос, который автоматически определяет конструктор на основе ключевого слова для типа, объявленного в выражении typedef, которое должно быть выражением struct или mutable struct Julia. Аргумент по умолчанию указывается при объявлении полей видаfield::T = defaultorfield = default. Если значение по умолчанию не указано, именованный аргумент становится обязательным именованным аргументом в конструкторе результирующего типа.

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

Примеры

# abstract type — Keyword

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

У Number нет супертипа, в то время как Real является абстрактным подтипом типа Number.

# primitive type — Keyword

primitive type объявляет конкретный тип, данные которого состоят только из последовательности битов. Классическими примерами примитивных типов являются целые числа и значения с плавающей запятой. Вот некоторые примеры встроенных объявлений примитивных типов.

Число после имени означает то, сколько битов требуется для хранения типа. В настоящее время поддерживаются только размеры, кратные 8 битам. Объявление Bool демонстрирует, как примитивный тип можно объявить как подтип какого-либо супертипа.

# where — Keyword

Ключевое слово where создает тип, который является итерируемым объединением других типов по всем значениям некоторой переменной. Например, тип Vector{T} where T<:Real включает в себя все векторы (Vector), элементы которых являются вещественными числами (Real).

Если ограничивающая переменная не указана, по умолчанию она равна Any:

Переменные также могут иметь нижние границы:

Существует также сокращенный синтаксис для вложенных выражений where. Например, такой код:

можно сократить следующим образом:

Такая форма часто встречается в сигнатурах методов.

Обратите внимание, что при использовании такой формы записи переменные перечисляются начиная с самой внешней. Это соответствует порядку, в котором переменные подставляются при применении типа к значениям параметров с помощью синтаксиса T{p1, p2, ...}.

# ... — Keyword

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

Примеры

# ; — Keyword

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

Символ ; необязательно должен стоять в конце строки: он может использоваться для отделения операторов в одной строке или для объединения операторов в одно выражение.

Если добавить ; в конец строки в REPL, результат этого выражения не выводится.

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

Если при создании массива аргументы в квадратных скобках разделяются символом ;, их содержимое объединяется по вертикали.

Если в стандартной среде REPL ввести символ ; в пустой строке, она переключится в режим оболочки.

Примеры

# = — Keyword

= — это оператор присваивания.

Примеры

При присваивании объекта b переменной a копия b не создается; для этого нужно использовать функцию copy или deepcopy.

Коллекции, передаваемые в функции, также не копируются. Функции могут изменять содержимое объектов, на которые ссылаются их аргументы. (К именам таких функций принято добавлять суффикс «!».)

Значения итерируемого объекта можно присваивать параллельно нескольким переменным:

Присваивать значения можно последовательно нескольким переменным. При этом возвращается значение самого правого выражения:

При присваивании по индексу, выходящему за границы, элементы в коллекцию не добавляются. Если коллекция имеет тип Vector, добавить в нее элементы можно с помощью функции push! или append!.

При присваивании [] элементы из коллекции не удаляются; вместо этого используйте функцию filter!.

# ?: — Keyword

Краткая форма записи условных операторов; означает «если a, вычислить b, в противном случае вычислить c». Также называется тернарным оператором.

Этот синтаксис эквивалентен if a; b else c end, но часто применяется, чтобы подчеркнуть выбор между b и c в рамках более сложного выражения, а не последствия вычисления b или c.

Дополнительные сведения см. в разделе руководства, посвященном порядку выполнения.

Примеры

# Main — Module

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

# Core — Module

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

# Base — Module

Базовая библиотека Julia. В модуле Base содержатся основные функции (содержимое base/). Во всех модулях неявно применяется команда using Base, так как эти функции необходимы в подавляющем большинстве случаев.

# Base.Broadcast — Module

Модуль, содержащий реализацию трансляции.

# Base.Docs — Module

Модуль Docs предоставляет макрос @doc, с помощью которого можно задавать и получать метаданные документации для объектов Julia.

Дополнительные сведения см. в разделе руководства, посвященном документации .

# Base.Iterators — Module

Методы для работы с итераторами.

# Base.Libc — Module

Интерфейс для libc, стандартной библиотеки С.

# Base.Meta — Module

Вспомогательные функции для метапрограммирования.

# Base.StackTraces — Module

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

# Base.Sys — Module

Предоставляет методы получения информации об аппаратном обеспечении и операционной системе.

# Base.Threads — Module

Поддержка многопоточности.

# Base.GC — Module

Модуль со средствами сборки мусора.

# Core.:=== — Function

Определяет, являются ли x и y идентичными, то есть неотличимыми для любой программы. Сначала сравниваются типы x и y. Если они одинаковы, изменяемые объекты сравниваются по адресу в памяти, а неизменяемые (например, числа) — по содержимому на уровне битов. Иногда эту функцию называют egal. Она всегда возвращает значение типа Bool.

Примеры

# Core.isa — Function

Определяет, относится ли x к типу type. Также может применяться как инфиксный оператор, например x isa type.

Примеры

# Base.isequal — Function

Аналогично ==, за исключением обработки чисел с плавающей запятой и отсутствующих значений. Функция isequal расценивает все значения NaN с плавающей запятой как равные друг другу, значение -0.0 — как неравное 0.0, а значение missing — как равное в файл missing. Всегда возвращает значение типа Bool.

isequal — это отношение эквивалентности: оно рефлексивное (=== влечет isequal), симметричное (isequal(a, b) влечет isequal(b, a)) и транзитивное (isequal(a, b) и isequal(b, c) влечет isequal(a, c)).

Реализация

Реализация функции isequal по умолчанию вызывает ==, поэтому для типа, не связанного со значениями с плавающей запятой, как правило, достаточно использовать ==.

isequal — это функция сравнения, используемая хэш-таблицами (Dict). Из isequal(x,y) должно вытекать, что hash(x) == hash(y).

Обычно это означает, что типы, для которых существует пользовательский метод == или isequal, должны реализовывать соответствующий метод hash (и наоборот). Реализация isequal для коллекций обычно вызывает isequal рекурсивно для всего содержимого.

Кроме того, функция isequal связана с isless, и вместе они определяют фиксированный общий порядок: только одно из выражений isequal(x, y), isless(x, y) или isless(y, x) должно быть равно true (а остальные два — false).

Скалярные типы обычно не требуют реализации isequal отдельно от ==, если только они не представляют числа с плавающей запятой, для которых возможна более эффективная реализация, чем универсальный метод (на основе isnan, signbit и ==).

Примеры

Создает функцию, аргумент которой сравнивается с x через isequal, т. е. функцию, эквивалентную y -> isequal(y, x).

Возвращаемая функция имеет тип Base.Fix2{typeof(isequal)} и может использоваться для реализации специализированных методов.

# Base.isless — Function

Проверяет, меньше ли x, чем y, в соответствии с фиксированным общим порядком (определяется в сочетании с функцией isequal). Функция isless определена не для всех пар значений (x, y). Однако если она определена, должны выполняться следующие условия.

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

Это сравнение по умолчанию, используемое функцией sort.

Реализация

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

Примеры

# Base.ifelse — Function

Возвращает x, если condition равно true, в противном случае возвращает y. Отличается от ? или if тем, что это обычная функция, поэтому сначала вычисляются все аргументы. В некоторых случаях использование ifelse вместо оператора if позволяет устранить ветвление в сформированном коде и обеспечить более высокую производительность сплошных циклов.

Примеры

# Core.typeassert — Function

Вызывает ошибку TypeError, если не выполняется условие x isa type. Эта функция вызывается при использовании синтаксиса x::type.

Примеры

# Core.typeof — Function

Возвращает конкретный тип аргумента x.

См. также описание eltype.

Примеры

# Core.tuple — Function

Создает кортеж из указанных объектов.

См. также описание Tuple и NamedTuple.

Примеры

# Base.ntuple — Function

Создает кортеж длины n, каждый элемент которого вычисляется с помощью функции f(i), где i — индекс элемента.

Примеры

Создает кортеж длины N, каждый элемент которого вычисляется с помощью функции f(i), где i — индекс элемента. Благодаря аргументу Val(N) код, создаваемый с помощью этого варианта функции ntuple, может быть эффективнее, чем при указании длины в виде целого числа. Но вариант ntuple(f, N) предпочтительнее ntuple(f, Val(N)) в случаях, когда N невозможно определить во время компиляции.

Примеры

# Base.objectid — Function

Возвращает хэш-значение для x на основе идентификатора объекта.

Если x === y, то objectid(x) == objectid(y), и обычно когда x !== y, objectid(x) != objectid(y).

См. также описание hash и IdDict.

# Base.hash — Function

Вычисляет такой целочисленный хэш-код, что из isequal(x,y) следует hash(x)==hash(y).Необязательный второй аргумент h — это хэш-код, смешиваемый с результатом.

Для новых типов должна реализовываться форма с двумя аргументами. Для этого обычно функция hash с двумя аргументами вызывается рекурсивно с целью смешивания хэшей содержимого друг с другом (и с h). Как правило, любой тип, для которого реализована функция hash, должен также иметь собственную реализацию == (а следовательно, и isequal), чтобы выполнялось указанное выше условие. Типы, поддерживающие вычитание (оператор -), также должны реализовывать функцию widen, которая нужна для хэширования значений в неоднородных массивах.

См. также описание objectid, Dict, Set.

# Base.finalizer — Function

Регистрирует функцию f(x), которая должна вызываться при отсутствии доступных программе ссылок на x и возвращается x. x должен иметь тип mutable struct, иначе эта функция выдаст ошибку.

Функция f не должна вызывать переключение задач, а значит, исключается большинство операций ввода-вывода, таких как println. В целях отладки может быть полезно использовать макрос @async (чтобы отложить переключение контекста до завершения выполнения финализатора) или ключевое слово ccall для вызова функций ввода-вывода на языке C напрямую.

Обратите внимание, что для выполнения функции f не гарантируется наличие «возраста мира». Ее можно вызывать в том «возрасте мира», в котором был зарегистрирован финализатор, или в любом более позднем «возрасте мира».

Примеры

Финализатор может быть зарегистрирован при создании объекта. Обратите внимание: в следующем примере неявно предполагается, что финализатор возвращает созданную изменяемую структуру x.

Пример

# Base.finalize — Function

Немедленно выполняет финализаторы, зарегистрированные для объекта x.

# Base.copy — Function

Создает поверхностную копию x: копируется внешняя структура, но не внутренние значения. Например, при копировании массива создается массив с теми же элементами, что и у исходного.

См. также описание функций copy!, copyto! и deepcopy.

# Base.deepcopy — Function

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

Хотя обычно это не требуется, в определяемых пользователем типах можно переопределить поведение функции deepcopy по умолчанию. Для этого определяется специализированная версия функции deepcopy_internal(x::T, dict::IdDict) (которая в иных целях не используется). Здесь T — это тип, для которого переопределяется функция, а dict отслеживает объекты, копируемые рекурсивно. В определении deepcopy_internal следует использовать вместо deepcopy, а переменную dict следует обновить соответствующим образом перед возвратом.

# Base.getproperty — Function

Синтаксис a.b вызывает getproperty(a, :b). С помощью синтаксиса @atomic order a.b делается вызов getproperty(a, :b, :order), а с помощью синтаксиса @atomic a.b — вызов getproperty(a, :b, :sequentially_consistent).

Примеры

См. также описание функций getfield, propertynames и setproperty!.

# Base.setproperty! — Function

Синтаксис a.b = c вызывает setproperty!(a, :b, c). С помощью синтаксиса @atomic order a.b = c делается вызов setproperty!(a, :b, c, :order), а с помощью синтаксиса @atomic a.b = c — вызов setproperty!(a, :b, c, :sequentially_consistent).

См. также описание функций setfield!, propertynames и getproperty.

# Base.propertynames — Function

Возвращает кортеж или вектор свойств (x.property) объекта x. Обычно действует так же, как fieldnames(typeof(x)), но типы, которые перегружают функцию getproperty, как правило, должны также перегружать propertynames для получения свойств экземпляра типа.

Функция propertynames(x) может возвращать имена только общедоступных свойств, входящих в задокументированный интерфейс объекта x. Если нужно также вернуть имена частных свойств, предназначенных для внутреннего использования, передайте значение true для необязательного второго аргумента. При автозавершении клавишей TAB в REPL для x. отображаются только свойства, для которых private=false.

См. также описание hasproperty, hasfield.

# Base.hasproperty — Function

Возвращает логическое значение, указывающее, является ли s одним из собственных свойств объекта x.

См. также описание propertynames, hasfield.

# Core.getfield — Function

Извлекает поле из составного объекта value по имени или позиции. При необходимости для этой операции можно указать порядок. Если поле объявлено с ключевым словом @atomic, настоятельно рекомендуется, чтобы указанный порядок был совместим с операциями сохранения в этом расположении. В противном случае, если объявление @atomic отсутствует и этот параметр указан, он должен быть :not_atomic. См. также описание getproperty и fieldnames.

Примеры

# Core.setfield! — Function

Присваивает x именованному полю объекта value составного типа. Объект value должен быть изменяемым, а x — подтипом fieldtype(typeof(value), name). Кроме того, для этой операции можно указать порядок. Если поле объявлено с ключевым словом @atomic, указывать порядок необходимо. В противном случае, если объявление @atomic отсутствует и этот параметр указан, он должен быть :not_atomic. См. также описание setproperty!.

Примеры

# Core.isdefined — Function

Проверяет, определена ли глобальная переменная или поле объекта. Аргументами могут быть модуль и символ, составной объект и имя поля (в виде символа) или индекс. При необходимости для этой операции можно указать порядок. Если поле объявлено с ключевым словом @atomic, настоятельно рекомендуется, чтобы указанный порядок был совместим с операциями сохранения в этом расположении. В противном случае, если объявление @atomic отсутствует и этот параметр указан, он должен быть :not_atomic.

Чтобы проверить, определен ли элемент массива, используйте вместо этого функцию isassigned.

См. также описание @isdefined.

Примеры

# Core.getglobal — Function

Получает значение привязки name из модуля module. При необходимости для этой операции можно указать атомарное упорядочение, в противном случае по умолчанию будет использоваться монотонное.

Хотя доступ к привязкам модулей с помощью getfield все еще поддерживается для обеспечения совместимости, всегда следует отдавать предпочтение getglobal, поскольку getglobal позволяет контролировать атомарное упорядочение (getfield всегда является монотонным) и лучше обозначает цель кода как для пользователя, так и для компилятором.

Большинство пользователей не должны вызывать эту функцию напрямую. Во всех случаях, кроме очень специфических, следует использовать функцию getproperty или соответствующий синтаксис т. е. module.name).

См. также описание getproperty и setglobal!.

Примеры

# Core.setglobal! — Function

Задает или изменяет значение имени (name) привязки в модуле module на x. Преобразование типа не выполняется, поэтому если тип уже был объявлен для привязки, x должен иметь соответствующий тип, иначе возникнет ошибка.

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

Обычно пользователи обращаются к этой функциональности с помощью функции setproperty! или соответствующего синтаксиса (т. е. module.name = x), поэтому она предназначена только для очень специфических вариантов использования.

См. также описание setproperty! и getglobal.

Примеры

# Base.@isdefined — Macro

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

См. также описание функции isdefined, которая проверяет свойства полей, функции isassigned, которая проверяет индексы массива, и функции haskey, которая проверяет другие сопоставления.

Примеры

# Base.convert — Function

Преобразует x в значение типа T.

Если T — целочисленный тип (Integer), возникает ошибка InexactError в случае, когда значение x не может быть представлено как тип T, например, если значение x не целочисленное или выходит за пределы диапазона, поддерживаемого типом T.

Примеры

Если T — это тип AbstractFloat, возвращается ближайшее к x значение, поддерживаемое типом T.

Если T — это тип-коллекция, а x — коллекция, функция convert(T, x) может возвращать псевдоним для всего объекта x или его части.

См. также описание round, trunc, oftype, reinterpret.

# Base.promote — Function

Преобразует все аргументы в общий тип и возвращает их в виде кортежа. Если невозможно преобразовать ни один из аргументов, происходит ошибка.

См. также описание promote_type, promote_rule.

Примеры

# Base.oftype — Function

Преобразует y в тип объекта x, т. е. convert(typeof(x), y).

Примеры

# Base.widen — Function

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

Для целочисленных типов фиксированного размера длиной менее 128 битов функция widen возвращает тип с удвоенным количеством битов.

Если x — это значение, оно преобразуется в widen(typeof(x)).

Примеры

# Base.identity — Function

Функция тождественности. Возвращает свой аргумент.

См. также описание функций one и oneunit и оператора I из библиотеки LinearAlgebra.

Примеры

# Core.Any — Type

Any — это объединение всех типов. Имеет характерное свойство isa(x, Any) == true для любого x. Таким образом, Any описывает всю совокупность возможных значений. Например, Integer является подмножеством типа Any, включающим Int, Int8 и другие целочисленные типы.

# Core.Union — Type

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

Примеры

# Union{} — Keyword

Union{}, то есть пустое объединение (Union) типов, — это тип без значений. Оно имеет характерное свойство isa(x, Union{}) == false для любого x. Для объединения Union{} определен псевдоним Base.Bottom, а его тип — Core.TypeofBottom.

Примеры

# Core.UnionAll — Type

Объединение типов по всем значениям параметра типа. UnionAll используется для описания параметрических типов, у которых значения некоторых параметров неизвестны.

Примеры

# Core.Tuple — Type

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

Типы кортежей ковариантны по своим параметрам: Tuple{Int} является подтипом Tuple{Any}. Поэтому Tuple{Any} считается абстрактным типом, а типы кортежей являются конкретными, только если таковыми являются их параметры. У кортежей нет имен полей; поля доступны только по индексам.

См. раздел руководства, посвященный типам кортежей.

См. также Vararg, NTuple, tuple, NamedTuple.

# Core.NTuple — Type

Компактный способ представления типа кортежа длиной N, все элементы которого относятся к типу T.

Примеры

# Core.NamedTuple — Type

NamedTuple, как следует из названия, — это именованный кортеж (Tuple). То есть это подобная кортежу коллекция значений, каждый элемент которой имеет уникальное имя, представленное Symbol. Как и тип Tuple, тип NamedTuple является неизменяемым: ни имена, ни значения нельзя изменить напрямую после создания.

Получить доступ к значению, связанному с именем, в именованном кортеже можно с помощью синтаксиса доступа к полям, например x.a, или с помощью функции getindex, например x[:a] или x[(:a, :b)]. Кортеж имен можно получить с помощью функции keys, а кортеж значений — с помощью функции values.

Объявлять типы NamedTuple удобно с помощью макроса @NamedTuple.

Примеры

Так же как и в случае с программным определением именованных аргументов, именованный кортеж можно создать путем указания пары name::Symbol => value или распаковки итератора, который создает такие пары, после точки с запятой внутри литерала кортежа:

Как и в случае с именованными аргументами, идентификаторы и точечные выражения предполагают использование имен:

# Base.@NamedTuple — Macro

Этот макрос обеспечивает более удобный синтаксис для объявления типов NamedTuple. Он возвращает тип NamedTuple с указанными ключами и типами, что равносильно выражению NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}}. Если объявление ::Type пропущено, предполагается тип Any. Форма begin ... end позволяет разносить объявления на несколько строк (так же как и в случае с объявлением struct). В остальном такая форма ничем не отличается.

Например, кортеж (a=3.1, b="hello") имеет тип NamedTuple{(:a, :b),Tuple{Float64,String}}. С помощью макроса @NamedTuple его можно объявить так:

# Base.Val — Type

Возвращает тип Val{c}(), который не содержит данных времени выполнения. Такие типы можно использовать для передачи информации между функциями посредством значения c, которое должно иметь тип isbits или Symbol. Целью такой конструкции является возможность диспетчеризации констант напрямую (во время компиляции) без необходимости проверять их значения во время выполнения.

Примеры

# Core.Vararg — Constant

Последним параметром типа кортежа Tuple может быть специальное значение Vararg, которое означает любое количество элементов в конце. Выражению Vararg{T,N} соответствует ровно N элементов типа T. Наконец, выражению Vararg{T} соответствует ноль или более элементов типа T. Типы кортежей с параметром Vararg служат для представления аргументов, принимаемых методами с переменным числом аргументов (см. раздел руководства, посвященный функциям с переменным числом аргументов).

См. также описание NTuple.

Примеры

# Core.Nothing — Type

Тип без полей, являющийся типом константы nothing.

См. также описание isnothing, Some, Missing.

# Base.isnothing — Function

Возвращает true, если x === nothing, и false в противном случае.

См. также описание функций something, Base.notnothing и ismissing.

# Base.notnothing — Function

Вызывает ошибку, если x === nothing, и возвращает x в противном случае.

# Base.Some — Type

Тип-оболочка, используемый в объединении Union{Some{T}, Nothing}, чтобы отличать отсутствие значения (nothing) от наличия значения nothing (то есть Some(nothing)).

Для доступа к значению, заключенному в объект Some, используйте функцию something.

# Base.something — Function

Возвращает первое из значений аргументов, не равное nothing, если таковое имеется. В противном случае возникает ошибка. Аргументы типа Some не упаковываются.

См. также описание функций coalesce, skipmissing и @something.

Примеры

# Base.@something — Macro

Сокращенная версия функции something.

Примеры

# Base.Enums.Enum — Type

Абстрактный супертип всех перечислимых типов, определенных с помощью макроса @enum.

# Base.Enums.@enum — Macro

Создает подтип Enum{BaseType} с именем EnumName и элементами перечисления value1 и value2, которым могут быть присвоены значения x и y соответственно. EnumName можно использовать так же, как любые другие типы, а значения элементов перечисления — как обычные значения.

Примеры

Элементы перечисления также можно указать внутри блока begin, например:

Базовый тип BaseType (по умолчанию Int32) должен быть примитивным подтипом типа Integer. Значения элементов можно преобразовывать между типом перечисления и BaseType. read и write выполняют эти преобразования автоматически. Если перечисление создано с типом BaseType, отличным от типа по умолчанию, Integer(value1) возвращает целочисленное значение value1 с типом BaseType.

Для получения списка всех экземпляров перечисления используйте функцию instances, например:

Из экземпляра перечисления можно сконструировать символ:

# Core.Expr — Type

Тип, представляющий составные выражения в проанализированном коде Julia (AST). Каждое выражение состоит из части head Symbol, в которой указывается тип выражения (например, вызов, цикл for, условный оператор и т. д.), и подвыражений (например, аргументов вызова). Подвыражения хранятся в поле Vector{Any} с именем args.

См. главу руководства о метапрограммировании и раздел документации для разработчиков, посвященный синтаксису AST в Julia.

Примеры

# Core.Symbol — Type

Тип объекта, используемый для представления идентификаторов в проанализированном коде Julia (AST). Также часто применяется в качестве имени или метки для идентификации сущности (например, как ключа словаря). Объект Symbol можно ввести с помощью оператора цитирования ::

Объекты типа Symbol также можно создавать из строк или других значений путем вызова конструктора Symbol(x...).

Символы (Symbol) являются неизменяемыми, и в их реализации используется один и тот же объект для всех символов (Symbol) с одинаковым именем.

В отличие от строк, Symbol — это «атомарная» или «скалярная» сущность, которая не поддерживает итерацию по символам.

# Core.Symbol — Method

Создает объект Symbol путем объединения строковых представлений аргументов.

Примеры

# Core.Module — Type

Module (модуль) — это отдельная глобальная рабочая область переменных. Подробные сведения см. в описании ключевого слова module и разделе руководства, посвященном модулям.

Возвращает модуль с указанным именем. baremodule соответствует вызову Module(:ModuleName, false).

Пустой модуль, не содержащий ни одного имени, можно создать с помощью вызова Module(:ModuleName, false, false). В него не импортируются модули Base или Core, и он не содержит ссылку на себя.

# Core.Function — Type

Абстрактный тип для всех функций.

Примеры

# Base.hasmethod — Function

Определяет, имеет ли заданная универсальная функция метод, соответствующий указанному кортежу (Tuple) типов аргументов, с верхней границей «возраста мира» (иерархии определения методов), указанной в аргументе world.

Если предоставлен кортеж имен именованных аргументов kwnames, также проверяется наличие у метода f, соответствующего типу t, этих имен. Если метод принимает переменное число именованных аргументов, например посредством kwargs..., все имена в kwnames считаются соответствующими. В противном случае указанные имена должны быть подмножеством именованных аргументов метода.

См. также описание applicable.

Примеры

# Core.applicable — Function

Определяет, имеет ли заданная универсальная функция метод, применимый к указанным аргументам.

См. также описание hasmethod.

Примеры

# Base.isambiguous — Function

Определяет, могут ли два метода m1 и m2 быть неоднозначными для некоторой сигнатуры вызова. Эта проверка проводится в контексте других методов той же функции: сами по себе методы m1 и m2 могут быть неоднозначными, но если определен третий метод, устраняющий неоднозначность, возвращается значение false. И наоборот, сами по себе методы m1 и m2 могут быть упорядоченными, но если третий метод не может быть отсортирован вместе с ними, в совокупности возникает неоднозначность.

Для параметрических типов именованный аргумент ambiguous_bottom определяет то, считается ли объединение Union{} неоднозначным пересечением параметров типа: при значении true оно считается неоднозначным, а при значении false — нет.

Примеры

# Core.invoke — Function

Вызывает метод заданной универсальной функции f, который соответствует указанным типам argtypes, с передачей аргументов args и именованных аргументов kwargs. Аргументы args должны соответствовать типам, указанным в argtypes, то есть автоматическое преобразование не производится. Эта функция позволяет вызвать метод, который является не самым специфичным, что полезно в случаях, когда явным образом требуется поведение более общего определения (часто в рамках реализации более специфичного метода той же функции).

При использовании invoke для вызова функций, которые написаны кем-то другим, будьте осторожны. Определение, используемое для указанных типов argtypes, зависит от внутренней реализации, если только явным образом не заявляется, что вызов с определенными типами argtypes является частью общедоступного API. Например, в приведенном ниже примере функции f1 и f2 обычно будут взаимозаменяемыми, так как при обычном вызове (не с помощью invoke) разницы между ними нет. Однако эта разница становится заметной при использовании invoke.

Примеры

# Base.@invoke — Macro

Обеспечивает удобный способ вызова invoke путем расширения @invoke f(arg1::T1, arg2::T2; kwargs...) в invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...). Если аннотация типа аргумента не указана, он заменяется типом Core.Typeof этого аргумента. Чтобы вызвать метод, аргумент которого не типизирован или явно типизирован как Any, аннотируйте аргумент с помощью ::Any.

Примеры

# Base.invokelatest — Function

Вызывает f(args...; kwargs...), но гарантирует выполнение самого последнего метода f . Это полезно в особых ситуациях, например при выполнении длительных циклов событий или функций обратного вызова, которые могут вызывать устаревшие версии функции f. (Недостаток в том, что функция invokelatest выполняется немного медленнее, чем прямой вызов, f и тип результата не может быть выведен компилятором.)

# Base.@invokelatest — Macro

Обеспечивает удобный способ вызова invokelatest. @invokelatest f(args...; kwargs...) просто расширяется в Base.invokelatest(f, args...; kwargs...).

# new — Keyword

Специальная функция, доступная внутренним конструкторам и создающая новый объект типа. При использовании формы new{A,B,…​} значения параметров для параметрических типов указываются явным образом. Дополнительные сведения см. в разделе руководства, посвященном методам внутренних конструкторов .

# Base.:|> — Function

Инфиксный оператор, применяющий функцию f к аргументу x. Это позволяет записать f(g(x)) в виде x |> g |> f. При использовании анонимных функций обычно требуется заключить определение в круглые скобки, чтобы получить нужную цепочку.

Примеры

# Base.:∘ — Function

Композиция функций: (f ∘ g)(args...; kwargs...) означает f(g(args...; kwargs...)). Символ ∘ можно добавить в REPL Julia (и большинство редакторов, настроенных соответствующим образом), введя \circ<tab>.

Композиция функций также возможна в префиксной форме: ∘(f, g) равносильно f ∘ g. Префиксная форма поддерживает композицию нескольких функций (∘(f, g, h) = f ∘ g ∘ h) и распаковку (∘(fs...)) для составления итерируемой коллекции функций. Последний аргумент для ∘ выполняется первым.

Примеры

См. также описание ComposedFunction и !f::Function.

# Base.ComposedFunction — Type

Представляет композицию двух вызываемых объектов outer::Outer и inner::Inner. То есть

Для создания экземпляра типа ComposedFunction предпочтительнее использовать оператор композиции ∘:

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

См. также описание ∘.

# Base.splat — Function

Эквивалентно

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

Пример использования:

# Base.Fix1 — Type

Тип, представляющий функцию с двумя аргументами f, которая применяется частично: первый аргумент имеет фиксированное значение x. Иными словами, Fix1(f, x) действует аналогично y->f(x, y).

См. также описание Fix2.

# Base.Fix2 — Type

Тип, представляющий функцию с двумя аргументами f, которая применяется частично: второй аргумент имеет фиксированное значение x. Иными словами, Fix2(f, x) действует аналогично y->f(y, x).

# Core.eval — Function

Вычисляет выражение в указанном модуле и возвращает результат.

# Base.MainInclude.eval — Function

Вычисляет выражение в глобальной области содержащего модуля. У каждого модуля Module (кроме объявленных с ключевым словом baremodule) есть собственное определение функции eval с одним аргументом, которое вычисляет выражения в этом модуле.

# Base.@eval — Macro

Вычисляет выражение со значениями, которые интерполированы в него с помощью функции eval. Если указаны два аргумента, первый содержит модуль, в котором должно быть произведено вычисление.

# Base.evalfile — Function

Загружает файл в анонимный модуль с помощью функции include, вычисляет все выражения и возвращает значение последнего. Необязательный аргумент args можно использовать для задания входных аргументов скрипта (т. е. глобальной переменной ARGS). Обратите внимание, что определения (например, методы, глобальные объекты) обрабатываются в анонимном модуле и не влияют на текущий модуль.

Пример

# Base.esc — Function

Действует только в контексте выражения Expr, возвращаемого макросом. Предотвращает преобразование внедренных переменных при гигиенической передаче в макрос в переменные gensym. Подробные сведения и примеры см. в разделе Макросы главы руководства, посвященной метапрограммированию.

# Base.@inbounds — Macro

Отключает проверку границ массивов в выражениях.

В приведенном ниже примере проверка вхождения в диапазон при обращении к элементу i массива A пропускается для повышения производительности.

# Base.@boundscheck — Macro

Помечает выражение blk как блок проверки границ, благодаря чему он может игнорироваться блоком @inbounds.

Примеры

# Base.@propagate_inbounds — Macro

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

# Base.@inline — Macro

Дает компилятору указание на то, что эта функция может быть встроена.

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

Макрос @inline можно применять непосредственно перед определением или в теле функции.

Дает компилятору указание на то, что вызовы внутри блока block могут быть встроены.

# Base.@noinline — Macro

Дает компилятору указание на то, что функцию встраивать не следует.

Небольшие функции обычно встраиваются автоматически. Применяя к ним макрос @noinline, можно предотвратить это.

Макрос @noinline можно применять непосредственно перед определением или в теле функции.

Дает компилятору указание на то, что вызовы внутри блока block встраивать не следует.

# Base.@nospecialize — Macro

При применении к имени аргумента функции дает компилятору указание на то, что метод не следует специализировать для разных типов этого аргумента: для каждого аргумента должен использоваться объявленный тип. Он может применяться к аргументу в формальном списке аргументов или в теле функции. При применении к аргументу макрос должен охватывать все его выражение, например @nospecialize(x::Real) или @nospecialize(i::Integer...), а не только имя аргумента. При использовании в теле функции макрос должен находиться в положении оператора перед остальным кодом.

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

Восстановить поведение специализации по умолчанию можно с помощью макроса @specialize.

Пример

Здесь результатом аннотации @nospecialize является эквивалент

гарантируя, что для g будет сгенерирована только одна версия машинного кода, которая является универсальной для любого массива AbstractArray. Однако и для g, и для f определяется конкретный возвращаемый тип, который по-прежнему используется для оптимизации вызывающих сторон f и g.

# Base.@specialize — Macro

Восстанавливает поведение специализации по умолчанию для аргумента. Подробные сведения см. в описании макроса @nospecialize.

# Base.gensym — Function

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

# Base.@gensym — Macro

Создает символ gensym для переменной. Например, @gensym x y преобразовывается в x = gensym("x"); y = gensym("y").

# var"name" — Keyword

Синтаксис var"example" позволяет обращаться к переменной с именем Symbol("example"), даже если example не является допустимым именем в Julia.

Это может быть полезно для совместимости с языками программирования, в которых действуют другие правила построения допустимых имен. Например, для обращения к переменной R с именем draw.segments можно использовать выражение var"draw.segments" в коде Julia.

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

Обратите внимание, что этот синтаксис требует поддержки анализатором, поэтому он расширяется непосредственно анализатором, а не реализуется как обычный строковый макрос @var_str.

# Base.@goto — Macro

С помощью выражения @goto name производится безусловный переход к оператору в расположении @label name.

Макросы @label и @goto не позволяют переходить к другим операторам верхнего уровня. При попытке сделать это произойдет ошибка. Для использования @goto заключите макросы @label и @goto в блок.

# Base.@label — Macro

Присваивает оператору символьную метку name. Метка обозначает конечную точку безусловного перехода с помощью @goto name.

# Base.SimdLoop.@simd — Macro

Помечает цикл for, сообщая компилятору, что он может более свободно переупорядочивать его.

Объект, по которому осуществляется итерация в цикле @simd for, должен быть одномерным диапазоном. При использовании макроса @simd утверждается несколько свойств цикла.

Во многих случаях Julia может автоматически векторизовать внутренние циклы for без использования макроса @simd. Использование @simd дает компилятору дополнительную свободу, так что векторизация становится возможной и в других ситуациях. В любом случае для векторизации внутреннего цикла он должен обладать следующими свойствами.

# Base.@polly — Macro

Предписывает компилятору применить к функции полиэдрический оптимизатор Polly.

# Base.@generated — Macro

@generated помечает функцию как генерируемую. В теле генерируемой функции доступны только типы аргументов (но не их значения). Функция возвращает цитируемое выражение, которое вычисляется при вызове функции. Макрос @generated не следует применять к функциям, изменяющим глобальную область или зависящим от изменяемых элементов.

Дополнительные сведения см. в главе о метапрограммировании.

Примеры

# Base.@pure — Macro

Макрос @pure дает компилятору указание определить чистую функцию, что облегчает вывод типов.

# Base.@assume_effects — Macro

Макрос @assume_effects переопределяет модель побочных эффектов компилятора для указанного метода. ex должно быть определением метода или выражением @ccall.

Примеры

Как правило, каждое значение setting делает утверждение о поведении функции, не требуя от компилятора подтверждения такого значения. Такие утверждения делаются для всех «возрастов мира». Поэтому рекомендуется избегать использования универсальных функций, которые позднее могут быть расширены так, что утверждения станут недействительными (что приведет к неопределенному поведению).

Поддерживаются следующие значения setting:

Расширенная справка

:consistent

Значение :consistent утверждает следующее для идентичных входных данных (===):

:effect_free

Значение :effect_free утверждает, что метод лишен внешне семантически видимых побочных эффектов. Вот неполный список таких эффектов:

Однако следующие побочные эффекты не являются явно семантически видимыми, даже если они могут наблюдаться:

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

:nothrow

Значение :nothrow утверждает, что выполнение данного метода не завершается с ошибкой (то есть метод либо всегда возвращает значение, либо никогда не возвращает управление).

:terminates_globally

Значение :terminates_globally утверждает, что выполнение данного метода в конечном итоге завершается (с ошибкой или без), то есть не уходит в бесконечный цикл.

:terminates_locally

Значение :terminates_locally аналогично значению :terminates_globally за тем исключением, что применяется оно к синтаксическому порядку выполнения только внутри аннотированного метода. Таким образом, это гораздо менее строгое (и потому более безопасное) утверждение, которое допускает возможность бесконечного выполнения, если оно обусловлено другим вызываемым методом.

:notaskstate

Параметр :notaskstate утверждает, что метод не использует или не изменяет состояние локальной задачи (локальное хранилище задачи, состояние RNG и т. д.) и поэтому может безопасно перемещаться между задачами без заметных результатов.

:inaccessiblememonly

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

:foldable

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

:total

Это значение setting представляет собой наиболее полный набор побочных эффектов. В настоящее время оно эквивалентно следующим значениям setting:

Исключение побочных эффектов

Перед именами побочных эффектов можно ставить префикс !. Он означает, что эффект должен быть исключен из ранее определенного метаэффекта. Например, :total !:nothrow означает, что к вызову применяются все утверждения, но он может завершаться ошибкой.

Сравнение с макросом @pure

Макрос @assume_effects :foldable схож с макросом @pure: основное отличие в том, что, как описывалось ранее, требование согласованности (:consistent) применяется на уровне «возраста мира», а не глобально. Однако метод с аннотацией @pure всегда должен соответствовать по крайней мере утверждению :foldable. Еще одно преимущество в том, что побочные эффекты, которые утверждаются с помощью @assume_effects, переносятся на вызывающие объекты межпроцедурно, а чистота, объявляемая с помощью макроса @pure, — нет.

# Base.@deprecate — Macro

Выводит из использования метод old, заменяя его вызовом new, определяя в процессе новый метод old с указанной сигнатурой.

Чтобы запретить экспорт метода old, задайте export_old значение false.

Примеры

Вызовы макроса @deprecate без явных аннотаций типов определят устаревшие методы, принимающие любое количество позиционных и именованных аргументов типа Any.

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

определит и выведет из использования метод old(x::Int), который является зеркальным отражением new(x::Int), но не определит и не выведет из использования метод old(x::Float64).

# Base.Missing — Type

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

См. также описание skipmissing, nonmissingtype, Nothing.

# Base.missing — Constant

Единственный экземпляр типа Missing, представляющий отсутствующее значение.

См. также описание NaN, skipmissing, nonmissingtype.

# Base.coalesce — Function

Возвращает первое из значений аргументов, не равное missing, если таковое имеется. В противном случае возвращает missing.

См. также описание функций skipmissing, something и @coalesce.

Примеры

# Base.@coalesce — Macro

Сокращенная версия функции coalesce.

Примеры

# Base.ismissing — Function

Определяет, имеет ли аргумент x значение missing.

См. также описание skipmissing, isnothing, isnan.

# Base.skipmissing — Function

Возвращает итератор по элементам аргумента itr, пропуская значения missing. Доступ к элементам возвращенного объекта возможен по индексам объекта itr, если тот поддерживает индексацию. Индексы, соответствующие отсутствующим значениям, недопустимы: они пропускаются функциями keys и eachindex, и при попытке их использования возникает исключение MissingException.

Используйте метод collect для получения массива (Array), содержащего значения, отличные от missing, itr. Обратите внимание: даже если itr — многомерный массив, результат всегда будет иметь тип Vector, так как удалить отсутствующие значения с сохранением измерений входного массива невозможно.

См. также описание функций coalesce, ismissing и something.

Примеры

# Base.nonmissingtype — Function

Если T — объединение типов, включающее тип Missing, возвращает новый тип без Missing.

Примеры

# Base.run — Function

Выполняет объект команды, заключенный в обратные апострофы (см. раздел, посвященный выполнению внешних программ, в руководстве). Выдает ошибку, если происходят какие-либо неполадки, включая завершение процесса с ненулевым состоянием (когда аргумент wait равен true).

Аргументы args... позволяют передать в команду дескрипторы файлов в таком же порядке, как и стандартные дескрипторы файлов Unix (например, stdin, stdout, stderr, FD(3), FD(4)...).

Если аргумент wait равен false, процесс выполняется асинхронно. Вы можете дождаться его завершения и проверить его состояние выхода, вызвав success для возвращенного объекта процесса.

Когда аргумент wait имеет значение false, потоки ввода-вывода процесса направляются в devnull. Когда аргумент wait имеет значение true, потоки ввода-вывода являются общими с родительским процессом. Для управления перенаправлением ввода-вывода используйте метод pipeline.

# Base.devnull — Constant

Используется при перенаправлении потоков: все записываемые в devnull данные удаляются. Эквивалентно /dev/null в Unix или NUL в Windows. Использование:

# Base.success — Function

Выполняет объект команды, заключенный в обратные апострофы (см. раздел, посвященный выполнению внешних программ, в руководстве), и сообщает, завершилось ли выполнение успешно (выход с кодом 0). Если запустить процесс не удается, возникает исключение.

# Base.process_running — Function

Определяет, выполняется ли процесс в данный момент.

# Base.process_exited — Function

Определяет, завершился ли процесс.

# Base.kill — Method

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

# Base.Sys.set_process_title — Function

Задает заголовок процесса. В некоторых операционных системах это холостая операция.

# Base.Sys.get_process_title — Function

Возвращает заголовок процесса. В некоторых системах всегда возвращает пустую строку.

# Base.ignorestatus — Function

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

# Base.detach — Function

Помечает объект команды так, что он выполняется в новой группе процессов, благодаря чему он может продолжать существовать после завершения процесса Julia и в него не передаются прерывания CTRL+C.

# Base.Cmd — Type

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

Если какие-либо именованные аргументы не указаны, используются текущие значения из cmd. Обычно для создания объекта Cmd используются обратные апострофы, например:

# Base.setenv — Function

Задает переменные среды, используемые при выполнении указанной команды command. env — это объект типа словарь со строковыми ключами и значениями, либо массив строк в форме "var=val", либо ноль или несколько аргументов в виде пар "var"=>val. Чтобы изменить (а не заменить) существующую среду, создайте env с помощью copy(ENV), а затем задайте env["var"]=val нужным образом, или используйте функцию addenv.

С помощью именованного аргумента dir можно указать рабочий каталог для команды. По умолчанию аргумент dir равен текущему заданному значению dir для command (то есть текущему рабочему каталогу, если это значение не было переопределено).

См. также Cmd, addenv, ENV, pwd.

# Base.addenv — Function

Объединяет новые переменные среды со средой указанного объекта Cmd, возвращая новый объект Cmd. Если ключи повторяются, соответствующие переменные заменяются. Если в объекте, переданном в аргументе command, значения переменных среды еще не заданы, при вызове функции addenv() наследуется текущая среда при условии, что аргумент inherit имеет значение true. Ключи со значением nothing удаляются из env.

См. также описание функций Cmd, setenv и ENV.

# Base.withenv — Function

Выполняет функцию f в среде, которая временно изменена (а не заменена, как при использовании setenv) с помощью одного или нескольких аргументов kv в виде пар "var"=>val. Функция withenv обычно применяется с синтаксисом withenv(kv...) do ... end. С помощью значения nothing можно временно отключить переменную среды (если она задана). Когда функция withenv возвращает управление, восстанавливается исходная среда.

# Base.setcpuaffinity — Function

Задает привязку к ЦП для команды command в виде списка идентификаторов ЦП cpus (с отсчетом от 1). Передача значения cpus = nothing отменяет привязку к ЦП, если она была настроена для команды original_command.

Эта функция поддерживается только в Linux и Windows. В macOS она не поддерживается, так как библиотека libuv не поддерживает настройку привязки.

Примеры

В Linux увидеть, как работает функция setcpuaffinity, можно с помощью программы командной строки taskset.

Обратите внимание: значение маски 13 означает, что включены первый, второй и пятый биты (если считать от младшего разряда):

# Base.pipeline — Method

Создает конвейер из источника данных в конечный объект. Источником и конечным объектом могут быть команды, потоки ввода-вывода, строки или результаты других вызовов метода pipeline. По крайней мере один аргумент должен быть командой. Строки — это имена файлов. Если аргументов больше двух, они сцепляются слева направо. Например, вызов pipeline(a,b,c) эквивалентен pipeline(pipeline(a,b),c). Это позволяет определять многоступенчатые конвейеры более кратко.

Примеры:

# Base.pipeline — Method

Перенаправляет ввод-вывод в указанную команду command или из нее. Именованные аргументы определяют потоки команды, которые должны перенаправляться. Аргумент append определяет то, добавляются ли выходные данные PNG. Это более общая версия функции pipeline с двумя аргументами. Вызов pipeline(from, to) эквивалентен вызову pipeline(from, stdout=to), когда from — это команда, или вызову pipeline(to, stdin=from), когда from — это источник данных другого типа.

Примеры:

# Base.Libc.gethostname — Function

Возвращает имя хоста локального компьютера.

# Base.Libc.getpid — Method

Возвращает идентификатор процесса Julia.

# Base.Libc.getpid — Method

Возвращает идентификатор дочернего процесса, если он все еще существует.

# Base.Libc.time — Method

Возвращает системное время в секундах с начала отсчета Unix-времени с достаточно высокой точностью (обычно на уровне микросекунд).

# Base.time_ns — Function

Возвращает время в наносекундах. Время, соответствующее значению 0, не определено. Отсчет времени начинается заново каждые 5,8 года.

# Base.@time — Macro

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

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

Система может проверять содержимое выражения @time и компилировать вызываемый код, прежде чем начинать выполнение выражения верхнего уровня. В этом случае часть времени, затраченного на компиляцию, не учитывается. Чтобы учесть это время, можно выполнить @time @eval ....

См. также описание @showtime, @timev, @timed, @elapsed, @allocated и @allocations.

# Base.@showtime — Macro

Действует так же, как макрос @time, но также для справки выводит анализируемое выражение.

См. также описание @time.

# Base.@timev — Macro

Это подробная версия макроса @time. Сначала она выводит ту же информацию, что и @time, затем все ненулевые счетчики выделения памяти, а затем возвращает значение Julia.

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

См. также описание функций @time, @timed, @elapsed и @allocated и @allocations.

# Base.@timed — Macro

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

Система может проверять содержимое выражения @timed и компилировать вызываемый код, прежде чем начинать выполнение выражения верхнего уровня. В этом случае часть времени, затраченного на компиляцию, не учитывается. Чтобы учесть это время, можно выполнить @timed @eval ....

См. также описание функций @time, @timev, @elapsed и @allocated и @allocations.

# Base.@elapsed — Macro

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

Система может проверять содержимое выражения @elapsed и компилировать вызываемый код, прежде чем начинать выполнение выражения верхнего уровня. В этом случае часть времени, затраченного на компиляцию, не учитывается. Чтобы учесть это время, можно выполнить @elapsed @eval ....

См. также описание функций @time, @timev, @timed и @allocated и @allocations.

# Base.@allocated — Macro

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

См. также описание @allocations, @time, @timev, @timed, и @elapsed.

# Base.@allocations — Macro

Макрос, который вычисляет выражение, но вместо результата возвращает общее количество выделений в ходе вычисления.

См. также описание @allocated, @time, @timev, @timed, и @elapsed.

# Base.EnvDict — Type

Единственный экземпляр этого типа предоставляет интерфейс в виде хэш-таблицы для доступа к переменным среды.

# Base.ENV — Constant

Ссылка на тип EnvDict с единственным экземпляром, который предоставляет интерфейс в виде словаря для доступа к системным переменным среды.

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

Примеры

См. также описание withenv, addenv.

# Base.Sys.STDLIB — Constant

Строка, которая содержит полный путь к каталогу, где содержатся пакеты stdlib.

# Base.Sys.isunix — Function

Предикат для проверки того, предоставляет ли ОС Unix-подобный интерфейс. См. раздел документации Обработка операционной системы.

# Base.Sys.isapple — Function

Предикат для проверки того, является ли ОС производной от Apple Macintosh OS X или Darwin. См. раздел документации Обработка операционной системы.

# Base.Sys.islinux — Function

Предикат для проверки того, является ли ОС производной от Linux. См. раздел документации Обработка операционной системы.

# Base.Sys.isbsd — Function

Предикат для проверки того, является ли ОС производной от BSD. См. раздел документации Обработка операционной системы.

# Base.Sys.isfreebsd — Function

Предикат для проверки того, является ли ОС производной от FreeBSD. См. раздел документации Обработка операционной системы.

# Base.Sys.isopenbsd — Function

Предикат для проверки того, является ли ОС производной от OpenBSD. См. раздел документации Обработка операционной системы.

# Base.Sys.isnetbsd — Function

Предикат для проверки того, является ли ОС производной от NetBSD. См. раздел документации Обработка операционной системы.