Основы

Введение

Julia Base содержит множество функций и макросов, подходящих для научных и численных вычислений, но также достаточно обширных, как и функции многих языков общего назначения. Дополнительные возможности доступны из растущей коллекции доступных пакетов. Функции сгруппированы по темам ниже.

Некоторые общие замечания:

• Для использования функций модуля используйте import Module для импорта модуля и Module.fn(x) для использования функций.
• В качестве альтернативы, using Module импортирует все экспортированные Module функции в текущее пространство имен.
• По соглашению, имена функций, оканчивающиеся восклицательным знаком (!), изменяют свои аргументы. Некоторые функции имеют как изменяющие (например, sort!), так и неизменяющие (sort) версии.

Перемещение

Base.exitФункция

exit(code=0)

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

Base.atexitФункция

atexit(f)

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

Base.isinteractiveФункция

isinteractive() -> Bool

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

Base.summarysizeФункция

Base.summarysize(obj; exclude=Union{...}, chargeall=Union{...}) -> Int

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

Аргументы по ключевым словам

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

Base.requireФункция

require(into::Module, module::Symbol)

Эта функция является частью реализации using / import, если модуль еще не определен в Main. Также может быть вызвана напрямую для принудительной перезагрузки модуля, независимо от того, загружался он ранее (например, при интерактивном разработке библиотек).

Загружает исходный файл в контексте модуля Main на каждом активном узле, ищет файлы в стандартных расположениях. require считается операцией верхнего уровня, поэтому она устанавливает текущую include путь, но не использует его для поиска файлов (см. справку для include). Эта функция обычно используется для загрузки кода библиотеки и неявно вызывается using для загрузки пакетов.

При поиске файлов require сначала ищет код пакета в глобальном массиве LOAD_PATH. require регистрозависимая на всех платформах, включая те, где файлы регистронезависимые, такие как macOS и Windows.

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

Base.compilecacheФункция

Base.compilecache(module::PkgId)

Создает файл кеша предварительной компиляции для модуля и всех его зависимостей. Это можно использовать для сокращения времени загрузки пакетов. Файлы кеша хранятся в DEPOT_PATH[1]/compiled. См. Инициализация модуля и предварительная компиляция для важных замечаний.

Base.__precompile__Функция

__precompile__(isprecompilable::Bool)

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

Base.includeФункция

Base.include([m::Module,] path::AbstractString)

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

Base.MainInclude.includeФункция

include(path::AbstractString)

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

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

Base.include_stringФункция

include_string(m::Module, code::AbstractString, filename::AbstractString="string")

Подобно include, но читает код из заданной строки, а не из файла.

Base.include_dependencyФункция

include_dependency(path::AbstractString)

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

Это необходимо только если ваш модуль зависит от файла, который не используется через include. Вне компиляции это не имеет эффекта.

Base.whichМетод

which(f, types)

Возвращает метод f (объект Method) для аргументов заданного types.

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

Base.methodsФункция

methods(f, [types])

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

Если types задано, возвращает массив методов, типы которых соответствуют.

Base.@showМакрос

@show

Отображает выражение и результат, возвращая результат. См. также show.

ansКлючевое слово

ans

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

Ключевые слова

Вот список зарезервированных ключевых слов в Julia: baremodule, begin, break, catch, const, continue, do, else, elseif, end, export, false, finally, for, function, global, if, import, let, local, macro, module, quote, return, struct, true, try, using, while . Эти ключевые слова не могут использоваться в качестве имён переменных.

Следующие последовательности из двух слов зарезервированы: abstract type, mutable struct, primitive type. Однако вы можете создавать переменные с именами: abstract, mutable, primitive и type.

Наконец, where интерпретируется как инфиксный оператор для записи параметрических определений методов и типов. Также in и isa интерпретируются как инфиксные операторы. Тем не менее, разрешено создание переменных с именами where, in или isa.

moduleКлючевое слово

module

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

Примеры

module Foo
import Base.show
export MyType, foo

struct MyType
    x
end

bar(x) = 2x
foo(a::MyType) = bar(a.x) + 1
show(io::IO, a::MyType) = print(io, "MyType $(a.x)")
end

exportКлючевое слово

export

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

importКлючевое слово

import

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

usingКлючевое слово

using

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

baremoduleКлючевое слово

baremodule

baremodule объявляет модуль, который не содержит using Base или определения eval. Он всё ещё импортирует Core.

functionКлючевое слово

function

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

function add(a, b)
    return a + b
end

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

add(a, b) = a + b

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

macroКлючевое слово

macro

macro определяет метод для вставки сгенерированного кода в программу. Макрос отображает последовательность выражений аргументов в возвращаемое выражение, а полученное выражение подставляется непосредственно в программу в том месте, где вызывается макрос. Макросы — это способ запуска сгенерированного кода без вызова eval, так как сгенерированный код просто становится частью окружающего кода. Аргументы макроса могут включать выражения, литеральные значения и символы.

Примеры

julia> macro sayhello(name)
           return :( println("Hello, ", $name, "!") )
       end
@sayhello (macro with 1 method)

julia> @sayhello "Charlie"
Hello, Charlie!

returnКлючевое слово

return

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

function compare(a, b)
    a == b && return "equal to"
    a < b ? "less than" : "greater than"
end

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

function test1(xs)
    for x in xs
        iseven(x) && return 2x
    end
end

function test2(xs)
    map(xs) do x
        iseven(x) && return 2x
        x
    end
end

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

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

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

doКлючевое слово

do

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

map(1:10) do x
    2x
end

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

Используйте несколько аргументов следующим образом:

map(1:10, 11:20) do x, y
    x + y
end

beginКлючевое слово

begin

begin...end обозначает блок кода.

begin
    println("Hello, ")
    println("World!")
end

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

endКлючевое слово

end

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

Примеры

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> A[end, :]
2-element Array{Int64,1}:
 3
 4

letКлючевое слово

let

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

let var1 = value1, var2, var3 = value3
    code
end

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

ifКлючевое слово

if/elseif/else

if/elseif/else выполняет условное вычисление, что позволяет оценивать части кода или нет в зависимости от значения булевого выражения. Вот анатомия условного синтаксиса if/elseif/else.

if x < y
    println("x is less than y")
elseif x > y
    println("x is greater than y")
else
    println("x is equal to y")
end

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

forКлючевое слово

for

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

Примеры

julia> for i in [1, 4, 0]
           println(i)
       end
1
4
0

whileКлючевое слово

while

while циклы повторяют оценку условного выражения и продолжают вычисление тела цикла while, пока выражение остается истинным. Если условное выражение ложно, когда цикл while впервые достигается, тело никогда не оценивается.

Примеры

julia> i = 1
1

julia> while i < 5
           println(i)
           global i += 1
       end
1
2
3
4

breakКлючевое слово

break

Немедленно выйти из цикла.

Примеры

julia> i = 0
0

julia> while true
           global i += 1
           i > 5 && break
           println(i)
       end
1
2
3
4
5

continueКлючевое слово

continue

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

Примеры

julia> for i = 1:6
           iseven(i) && continue
           println(i)
       end
1
3
5

tryКлючевое слово

try/catch

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

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "Could not write file."
end

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

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

finallyКлючевое слово

finally

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

f = open("file")
try
    operate_on_file(f)
finally
    close(f)
end

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

quoteКлючевое слово

quote

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

ex = quote
    x = 1
    y = 2
    x + y
end

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

localКлючевое слово

local

local объявляет новую локальную переменную. Для получения дополнительной информации см. раздел руководства по области видимости переменных scope of variables.

Примеры

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # introduce a loop-local x
               x = i
           end
           x
       end
foo (generic function with 1 method)

julia> foo(10)
0

globalКлючевое слово

global

global x делает x в текущей области видимости и её вложенных областях видимости ссылаются на глобальную переменную с таким же именем. Для получения дополнительной информации см. раздел руководства по области видимости переменных scope of variables.

Примеры

julia> z = 3
3

julia> function foo()
           global z = 6 # use the z variable defined outside foo
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6

constКлючевое слово

const

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

const x = 5

Несколько переменных могут быть объявлены в одном const.

const y, z = 7, 11

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

Обратите внимание, что "постоянство" не распространяется на изменяемые контейнеры; постоянной является только связь между переменной и её значением. Если x — массив или словарь (например), вы всё равно можете изменять, добавлять или удалять элементы.

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

structКлючевое слово

struct

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

struct Point
    x
    y
end

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

    struct Point{X}
        x::X
        y::Float64
    end

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

struct Point <: AbstractPoint
    x
    y
end

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

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

mutable structКлючевое слово

mutable struct

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

abstract typeКлючевое слово

abstract type

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

abstract type Number end
abstract type Real <: Number end

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

primitive typeКлючевое слово

primitive type

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

primitive type Char 32 end
primitive type Bool <: Integer 8 end

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

whereКлючевое слово

where

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

Переменная по умолчанию — Any, если она опущена:

Vector{T} where T    # short for `where T<:Any`

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

Vector{T} where T>:Int
Vector{T} where Int<:T<:Real

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

Pair{T, S} where S<:Array{T} where T<:Number

может быть сокращено до:

Pair{T, S} where {T<:Number, S<:Array{T}}

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

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

...Ключевое слово

...

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

Примеры

julia> add(xs...) = reduce(+, xs)
add (generic function with 1 method)

julia> add(1, 2, 3, 4, 5)
15

julia> add([1, 2, 3]...)
6

julia> add(7, 1:100..., 1000:1100...)
111107

;Ключевое слово

;

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

Примеры

julia> function foo()
           x = "Hello, "; x *= "World!"
           return x
       end
foo (generic function with 1 method)

julia> bar() = (x = "Hello, Mars!"; return x)
bar (generic function with 1 method)

julia> foo();

julia> bar()
"Hello, Mars!"

=Ключевое слово

=

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

• Для переменной a и выражения b, a = b заставляет a ссылаться на значение b.
• Для функций f(x), f(x) = x определяет новую постоянную функцию f или добавляет новый метод к f, если f уже определена; это использование эквивалентно function f(x); x; end.
• a[i] = v вызывает setindex!(a,v,i).
• a.b = c вызывает setproperty!(a,:b,c).
• Внутри вызова функции, f(a=b) передает b в качестве значения ключевого аргумента a.
• Внутри скобок с запятыми, (a=1,) строит NamedTuple.

Примеры

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

julia> b = [1]; a = b; b[1] = 2; a
1-element Array{Int64,1}:
 2

julia> b = [1]; a = copy(b); b[1] = 2; a
1-element Array{Int64,1}:
 1

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

julia> function f!(x); x[:] .+= 1; end
f! (generic function with 1 method)

julia> a = [1]; f!(a); a
1-element Array{Int64,1}:
 2

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

julia> a, b = 4, 5
(4, 5)

julia> a, b = 1:3
1:3

julia> a, b
(1, 2)

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

julia> a = [1]; b = [2]; c = [3]; a = b = c
1-element Array{Int64,1}:
 3

julia> b[1] = 2; a, b, c
([2], [2], [2])

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

julia> a = [1, 1]; a[3] = 2
ERROR: BoundsError: attempt to access 2-element Array{Int64,1} at index [3]
[...]

julia> push!(a, 2, 3)
4-element Array{Int64,1}:
 1
 1
 2
 3

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

julia> a = collect(1:3); a[a .<= 1] = []
ERROR: DimensionMismatch("tried to assign 0 elements to 1 destinations")
[...]

julia> filter!(x -> x > 1, a) # in-place & thus more efficient than a = a[a .> 1]
2-element Array{Int64,1}:
 2
 3

Стандартные модули

MainМодуль

Main

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

julia> @__MODULE__
Main

CoreМодуль

Core

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

BaseМодуль

Base

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

Подмодули Base

Base.BroadcastМодуль

Base.Broadcast

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

Base.DocsМодуль

Docs

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

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

Base.IteratorsМодуль

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

Base.LibcМодуль

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

Base.MetaМодуль

Функции для метапрограммирования.

Base.StackTracesМодуль

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

Base.SysМодуль

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

Base.ThreadsМодуль

Экспериментальная поддержка многопоточности.

Base.GCМодуль

Base.GC

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

Все объекты

Core.:===Функция

===(x,y) -> Bool
≡(x,y) -> Bool

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

Примеры

julia> a = [1, 2]; b = [1, 2];

julia> a == b
true

julia> a === b
false

julia> a === a
true

Core.isaФункция

isa(x, type) -> Bool

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

Примеры

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true

Base.isequalФункция

isequal(x, y)

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

Реализация

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

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

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

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

Примеры

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

isequal(x)

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

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

Base.islessФункция

isless(x, y)

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

• Если isless(x, y) определена, то определены также isless(y, x) и isequal(x, y), и ровно одна из этих трёх возвращает true.
• Отношение, определённое isless является транзитивным, т.е., isless(x, y) && isless(y, z) подразумевает isless(x, z).

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

Это по умолчанию используется для сравнения в sort.

Реализация

Нечисловые типы с полным порядком должны реализовывать эту функцию. Числовые типы должны реализовать её только если они имеют специальные значения, такие как NaN. Типы с частичным порядком должны реализовывать <.

Core.ifelseФункция

ifelse(condition::Bool, x, y)

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

Примеры

julia> ifelse(1 > 2, 1, 2)
2

Core.typeassertФункция

typeassert(x, type)

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

Примеры

julia> typeassert(2.5, Int)
ERROR: TypeError: in typeassert, expected Int64, got Float64
Stacktrace:
[...]

Core.typeofФункция

typeof(x)

Получить конкретный тип x.

Примеры

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

julia> M = [1 2; 3.5 4];

julia> typeof(M)
Array{Float64,2}

Core.tupleФункция

tuple(xs...)

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

Примеры

julia> tuple(1, 'a', pi)
(1, 'a', π)

Base.ntupleФункция

ntuple(f::Function, n::Integer)

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

Примеры

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)

Base.objectidФункция

objectid(x)

Получить хеш-значение для x на основе идентификатора объекта. objectid(x)==objectid(y) если x === y.

Base.hashФункция

hash(x[, h::UInt])

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

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

Base.finalizerФункция

finalizer(f, x)

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

Base.finalizeФункция

finalize(x)

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

Base.copyФункция

copy(x)

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

Base.deepcopyФункция

deepcopy(x)

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

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

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

Base.getpropertyФункция

getproperty(value, name::Symbol)

Синтаксис a.b вызывает getproperty(a, :b).

Примеры

julia> struct MyType
           x
       end

julia> function Base.getproperty(obj::MyType, sym::Symbol)
           if sym === :special
               return obj.x + 1
           else # fallback to getfield
               return getfield(obj, sym)
           end
       end

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

См. также propertynames и setproperty!.

Base.setproperty!Функция

setproperty!(value, name::Symbol, x)

Синтаксис a.b = c вызывает setproperty!(a, :b, c).

См. также propertynames и getproperty.

Base.propertynamesФункция

propertynames(x, private=false)

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

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

Base.haspropertyФункция

hasproperty(x, s::Symbol)

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

Core.getfieldФункция

getfield(value, name::Symbol)

Извлечь именованное поле из value составного типа. См. также getproperty.

Примеры

julia> a = 1//2
1//2

julia> getfield(a, :num)
1

julia> a.num
1

Core.setfield!Функция

setfield!(value, name::Symbol, x)

Присвоить x именованному полю в value составного типа. value должно быть изменяемым, а x — подтипом fieldtype(typeof(value), name). См. также setproperty!.

Примеры

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

julia> setfield!(a, :field, 2);

julia> getfield(a, :field)
2

julia> a = 1//2
1//2

julia> setfield!(a, :num, 3);
ERROR: setfield! immutable struct of type Rational cannot be changed

Core.isdefinedФункция

isdefined(m::Module, s::Symbol)
isdefined(object, s::Symbol)
isdefined(object, index::Int)

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

Для проверки, определён ли элемент массива, используйте isassigned вместо этого.

См. также @isdefined.

Примеры

julia> isdefined(Base, :sum)
true

julia> isdefined(Base, :NonExistentMethod)
false

julia> a = 1//2;

julia> isdefined(a, 2)
true

julia> isdefined(a, 3)
false

julia> isdefined(a, :num)
true

julia> isdefined(a, :numerator)
false

Base.@isdefinedМакрос

@isdefined s -> Bool

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

См. также isdefined.

Примеры

julia> function f()
           println(@isdefined x)
           x = 3
           println(@isdefined x)
       end
f (generic function with 1 method)

julia> f()
false
true

Base.convertФункция

convert(T, x)

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

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

Примеры

julia> convert(Int, 3.0)
3

julia> convert(Int, 3.5)
ERROR: InexactError: Int64(3.5)
Stacktrace:
[...]

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

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(Rational{Int32}, x)
1//3

julia> convert(Rational{Int64}, x)
6004799503160661//18014398509481984

Если T — тип коллекции, а x — коллекция, результат convert(T, x) может использовать все или часть x.

julia> x = Int[1, 2, 3];

julia> y = convert(Vector{Int}, x);

julia> y === x
true

Base.promoteФункция

promote(xs...)

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

Примеры

julia> promote(Int8(1), Float16(4.5), Float32(4.1))
(1.0f0, 4.5f0, 4.1f0)

Base.oftypeФункция

oftype(x, y)

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

Примеры

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

Base.widenФункция

widen(x)

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

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

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

Примеры

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

Base.identityФункция

identity(x)

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

Примеры

julia> identity("Well, what did you expect?")
"Well, what did you expect?"

Свойства типов

Отношения типов

Base.supertypeФункция

supertype(T::DataType)

Возвращает супертип типа данных T.

Примеры

julia> supertype(Int32)
Signed

Core.:<:Функция

<:(T1, T2)

Оператор подтипа: возвращает true, если и только если все значения типа T1 также являются значениями типа T2.

Примеры

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}
false

Base.:>:Функция

>:(T1, T2)

Оператор супертипа, эквивалентен T2 <: T1.

Base.typejoinФункция

typejoin(T, S)

Возвращает ближайшего общего предка T и S, т. е. наиболее узкий тип, от которого оба наследуются.

Base.typeintersectФункция

typeintersect(T, S)

Вычислить тип, содержащий пересечение T и S.

Base.promote_typeФункция

promote_type(type1, type2)

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

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia> promote_type(Int16, Float16)
Float16

julia> promote_type(Int64, Float16)
Float16

julia> promote_type(Int8, UInt16)
UInt16

Base.promote_ruleФункция

promote_rule(type1, type2)

Указывает, какой тип должен использоваться функцией promote, если ей даны значения типов type1 и type2.

Base.isdispatchtupleФункция

isdispatchtuple(T)

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

Определенная структура

Base.isimmutableФункция

isimmutable(v) -> Bool

Возвращает true тогда и только тогда, когда значение v является неизменяемым. См. Изменяемые составные типы для обсуждения неизменяемости. Обратите внимание, что эта функция работает со значениями, поэтому, если вы передадите ей тип, она сообщит вам, что значение типа DataType является изменяемым.

Примеры

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

Base.isabstracttypeФункция

Base.isabstracttype(T)

Определите, был ли тип T объявлен как абстрактный тип (т. е. с использованием ключевого слова abstract).

Примеры

julia> Base.isabstracttype(AbstractArray)
true

julia> Base.isabstracttype(Vector)
false

Base.isprimitivetypeФункция

Base.isprimitivetype(T) -> Bool

Определите, был ли тип T объявлен как примитивный тип (т. е. с использованием ключевого слова primitive).

Base.isstructtypeФункция

Base.isstructtype(T) -> Bool

Определите, был ли тип T объявлен как тип структуры (т. е. с использованием ключевого слова struct или mutable struct).

Base.nameofМетод

nameof(t::DataType) -> Symbol

Получить имя (возможно, UnionAll-упакованного) DataType (без родительского модуля) в качестве символа.

Примеры

julia> module Foo
           struct S{T}
           end
       end
Foo

julia> nameof(Foo.S{T} where T)
:S

Base.fieldnamesФункция

fieldnames(x::DataType)

Получить кортеж с именами полей DataType.

Примеры

julia> fieldnames(Rational)
(:num, :den)

Base.fieldnameФункция

fieldname(x::DataType, i::Integer)

Получить имя поля i DataType.

Примеры

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

Base.hasfieldФункция

hasfield(T::Type, name::Symbol)

Возвращает логическое значение, указывающее, содержит ли T name в качестве одного из собственных полей.

Макет памяти

Base.sizeofМетод

sizeof(T::DataType)
sizeof(obj)

Размер, в байтах, канонического двоичного представления данного DataType T, если таковой имеется. Размер объекта obj в байтах, если он не DataType.

Примеры

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof([1.0:10.0;])
80

Если DataType T не имеет определенного размера, генерируется ошибка.

julia> sizeof(AbstractArray)
ERROR: Abstract type AbstractArray does not have a definite size.
Stacktrace:
[...]

Base.isconcretetypeФункция

isconcretetype(T)

Определите, является ли тип T конкретным типом, т. е. он может иметь прямые экземпляры (значения x, такие что typeof(x) === T).

Примеры

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

julia> isconcretetype(Vector{Complex{Float32}})
true

julia> isconcretetype(Union{})
false

julia> isconcretetype(Union{Int,String})
false

Base.isbitsФункция

isbits(x)

Возвращает true если x является экземпляром типа isbitstype.

Base.isbitstypeФункция

isbitstype(T)

Возвращает true если тип T является типом «простых данных», то есть неизменяемым и не содержит ссылок на другие значения, а только типы primitive и другие типы isbitstype . Типичными примерами являются числовые типы, такие как UInt8, Float64 и Complex{Float64}. Эта категория типов важна, поскольку они допустимы в качестве параметров типов, могут не отслеживать состояние isdefined / isassigned и имеют определённый макет, совместимый с C.

Примеры

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

Core.fieldtypeФункция

fieldtype(T, name::Symbol | index::Int)

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

Примеры

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

Base.fieldtypesФункция

fieldtypes(T::Type)

Объявленные типы всех полей в составном типе данных T в виде кортежа.

Примеры

julia> struct Foo
           x::Int64
           y::String
       end

julia> fieldtypes(Foo)
(Int64, String)

Base.fieldcountФункция

fieldcount(t::Type)

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

Base.fieldoffsetФункция

fieldoffset(type, i)

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

julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i)) for i = 1:fieldcount(T)];

julia> structinfo(Base.Filesystem.StatStruct)
12-element Array{Tuple{UInt64,Symbol,DataType},1}:
 (0x0000000000000000, :device, UInt64)
 (0x0000000000000008, :inode, UInt64)
 (0x0000000000000010, :mode, UInt64)
 (0x0000000000000018, :nlink, Int64)
 (0x0000000000000020, :uid, UInt64)
 (0x0000000000000028, :gid, UInt64)
 (0x0000000000000030, :rdev, UInt64)
 (0x0000000000000038, :size, Int64)
 (0x0000000000000040, :blksize, Int64)
 (0x0000000000000048, :blocks, Int64)
 (0x0000000000000050, :mtime, Float64)
 (0x0000000000000058, :ctime, Float64)

Base.datatype_alignmentФункция

Base.datatype_alignment(dt::DataType) -> Int

Минимальное выравнивание выделения памяти для экземпляров этого типа. Может вызываться для любого isconcretetype.

Base.datatype_haspaddingФункция

Base.datatype_haspadding(dt::DataType) -> Bool

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

Base.datatype_pointerfreeФункция

Base.datatype_pointerfree(dt::DataType) -> Bool

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

Специальные значения

Base.typeminФункция

typemin(T)

Наименьшее значение, представимое данным (вещественным) числовым типом данных T.

Примеры

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

Base.typemaxФункция

typemax(T)

Наибольшее значение, представимое данным (вещественным) числовым типом DataType.

Примеры

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

Base.floatminФункция

floatmin(T)

Наименьшее по абсолютной величине не-поднормализованное значение, представимое данным типом с плавающей запятой T.

Base.floatmaxФункция

floatmax(T)

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

Примеры

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

Base.maxintfloatФункция

maxintfloat(T=Float64)

Наибольшее целое значение с плавающей запятой, которое точно представляется в данном типе с плавающей запятой T (по умолчанию Float64).

То есть, maxintfloat возвращает наименьшее положительное целое значение с плавающей запятой n такое, что n+1 не точно представляется в типе T.

Когда требуется значение типа Integer, используйте Integer(maxintfloat(T)).

maxintfloat(T, S)

Наибольшее целое число, представимое в данном типе с плавающей запятой T и не превышающее максимальное целое число, представимое в типе целых чисел S. Эквивалентно, это минимум maxintfloat(T) и typemax(S).

Base.epsМетод

eps(::Type{T}) where T<:AbstractFloat
eps()

Возвращает машинную эпсилон типа с плавающей запятой T (по умолчанию T = Float64). Это определяется как зазор между 1 и следующим по величине значением, представимым typeof(one(T)), и эквивалентно eps(one(T)). (Поскольку eps(T) является границей относительной ошибки T, это безразмерная величина, как one.)

Примеры

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0

Base.epsМетод

eps(x::AbstractFloat)

Возвращает единицу в последнем разряде (ulp) x. Это расстояние между последовательными представимыми значениями с плавающей запятой в x. В большинстве случаев, если расстояние по обе стороны от x отличается, то берется большее из двух, то есть

eps(x) == max(x-prevfloat(x), nextfloat(x)-x)

Исключениями из этого правила являются наименьшие и наибольшие конечные значения (например, nextfloat(-Inf) и prevfloat(Inf) для Float64), которые округляются до меньшего из значений.

Обоснование этого поведения заключается в том, что eps ограничивает ошибку округления с плавающей запятой. При стандартном режиме округления, если $y$ — вещественное число, а $x$ — ближайшее число с плавающей запятой к $y$, то

Примеры

julia> eps(1.0)
2.220446049250313e-16

julia> eps(prevfloat(2.0))
2.220446049250313e-16

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # largest finite Float64
1.7976931348623157e308

julia> x + eps(x)/2            # rounds up
Inf

julia> x + prevfloat(eps(x)/2) # rounds down
1.7976931348623157e308

Base.instancesФункция

instances(T::Type)

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

Пример

julia> @enum Color red blue green

julia> instances(Color)
(red, blue, green)

Специальные типы

Core.AnyТип

Any::DataType

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

Core.UnionТип

Union{Types...}

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

Примеры

julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}

julia> 1 :: IntOrString
1

julia> "Hello!" :: IntOrString
"Hello!"

julia> 1.0 :: IntOrString
ERROR: TypeError: in typeassert, expected Union{Int64, AbstractString}, got Float64

Union{}Ключевое слово

Union{}

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

Примеры

julia> isa(nothing, Union{})
false

Core.UnionAllТип

UnionAll

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

Примеры

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Core.TupleТип

Tuple{Types...}

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

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

См. раздел руководства о типах кортежей.

Core.NamedTupleТип

NamedTuple

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

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

Примеры

julia> x = (a=1, b=2)
(a = 1, b = 2)

julia> x.a
1

julia> x[:a]
1

julia> keys(x)
(:a, :b)

julia> values(x)
(1, 2)

julia> collect(x)
2-element Array{Int64,1}:
 1
 2

julia> collect(pairs(x))
2-element Array{Pair{Symbol,Int64},1}:
 :a => 1
 :b => 2

Base.ValТип

Val(c)

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

Цель этой конструкции — возможность прямой диспетчеризации по константам (во время компиляции) без проверки значения константы во время выполнения.

Примеры

julia> f(::Val{true}) = "Good"
f (generic function with 1 method)

julia> f(::Val{false}) = "Bad"
f (generic function with 2 methods)

julia> f(Val(true))
"Good"

Core.VarargТип

Vararg{T,N}

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

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

Примеры

julia> mytupletype = Tuple{AbstractString,Vararg{Int}}
Tuple{AbstractString,Vararg{Int64,N} where N}

julia> isa(("1",), mytupletype)
true

julia> isa(("1",1), mytupletype)
true

julia> isa(("1",1,2), mytupletype)
true

julia> isa(("1",1,2,3.0), mytupletype)
false

Core.NothingТип

Nothing

Тип без полей, который является типом nothing.

Base.isnothingФункция

isnothing(x)

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

Base.SomeТип

Some{T}

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

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

Base.somethingФункция

something(x, y...)

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

Примеры

julia> something(nothing, 1)
1

julia> something(Some(1), nothing)
1

julia> something(missing, nothing)
missing

julia> something(nothing, nothing)
ERROR: ArgumentError: No value arguments present

Base.Enums.EnumТип

Enum{T<:Integer}

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

Base.Enums.@enumМакрос

@enum EnumName[::BaseType] value1[=x] value2[=y]

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

Примеры

julia> @enum Fruit apple=1 orange=2 kiwi=3

julia> f(x::Fruit) = "I'm a Fruit with value: $(Int(x))"
f (generic function with 1 method)

julia> f(apple)
"I'm a Fruit with value: 1"

julia> Fruit(1)
apple::Fruit = 1

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

@enum EnumName begin
    value1
    value2
end

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

Чтобы перечислить все экземпляры перечисления, используйте instances, например

julia> instances(Fruit)
(apple, orange, kiwi)

Core.ExprТип

Expr(head::Symbol, args...)

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

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

Примеры

julia> Expr(:call, :+, 1, 2)
:(1 + 2)

julia> dump(:(a ? b : c))
Expr
  head: Symbol if
  args: Array{Any}((3,))
    1: Symbol a
    2: Symbol b
    3: Symbol c

Core.SymbolТип

Symbol

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

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

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

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

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

Core.SymbolМетод

Symbol(x...) -> Symbol

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

Примеры

julia> Symbol("my", "name")
:myname

julia> Symbol("day", 4)
:day4

Core.ModuleТип

Module

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

Общие функции

Core.FunctionТип

Function

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

Примеры

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin)

julia> ans <: Function
true

Base.hasmethodФункция

hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=typemax(UInt)) -> Bool

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

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

См. также applicable.

Примеры

julia> hasmethod(length, Tuple{Array})
true

julia> hasmethod(sum, Tuple{Function, Array}, (:dims,))
true

julia> hasmethod(sum, Tuple{Function, Array}, (:apples, :bananas))
false

julia> g(; xs...) = 4;

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g accepts arbitrary kwargs
true

Core.applicableФункция

applicable(f, args...) -> Bool

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

См. также hasmethod.

Примеры

julia> function f(x, y)
           x + y
       end;

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

Core.invokeФункция

invoke(f, argtypes::Type, args...; kwargs...)

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

Примеры

julia> f(x::Real) = x^2;

julia> f(x::Integer) = 1 + invoke(f, Tuple{Real}, x);

julia> f(2)
5

Base.invokelatestФункция

invokelatest(f, args...; kwargs...)

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

newКлючевое слово

new

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

Base.:|>Функция

|>(x, f)

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

Примеры

julia> [1:5;] |> x->x.^2 |> sum |> inv
0.01818181818181818

Base.:∘Функция

f ∘ g

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

Примеры

julia> map(uppercase∘first, ["apple", "banana", "carrot"])
3-element Array{Char,1}:
 'A'
 'B'
 'C'

Синтаксис

Core.evalФункция

Core.eval(m::Module, expr)

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

Base.MainInclude.evalФункция

eval(expr)

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

Base.@evalМакрос

@eval [mod,] ex

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

Base.evalfileФункция

evalfile(path::AbstractString, args::Vector{String}=String[])

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

Base.escФункция

esc(e)

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

Base.@inboundsМакрос

@inbounds(blk)

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

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

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i = 1:length(A)
        @inbounds r += A[i]
    end
    return r
end

Base.@boundscheckМакрос

@boundscheck(blk)

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

Примеры

julia> @inline function g(A, i)
           @boundscheck checkbounds(A, i)
           return "accessing ($A)[$i]"
       end;

julia> f1() = return g(1:2, -1);

julia> f2() = @inbounds return g(1:2, -1);

julia> f1()
ERROR: BoundsError: attempt to access 2-element UnitRange{Int64} at index [-1]
Stacktrace:
 [1] throw_boundserror(::UnitRange{Int64}, ::Tuple{Int64}) at ./abstractarray.jl:455
 [2] checkbounds at ./abstractarray.jl:420 [inlined]
 [3] g at ./none:2 [inlined]
 [4] f1() at ./none:1
 [5] top-level scope

julia> f2()
"accessing (1:2)[-1]"

Base.@propagate_inboundsМакрос

@propagate_inbounds

Указывает компилятору встроить функцию, сохраняя контекст inbounds вызывающей функции.

Base.@inlineМакрос

@inline

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

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

@inline function bigfunction(x)
    #=
        Function Definition
    =#
end

Base.@noinlineМакрос

@noinline

Запрещает компилятору встраивать функцию.

Маленькие функции обычно встраиваются автоматически. Применение @noinline к маленьким функциям позволяет предотвратить автоматическое встраивание. Это показано в следующем примере:

@noinline function smallfunction(x)
    #=
        Function Definition
    =#
end

Base.@nospecializeМакрос

@nospecialize

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

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

Специализацию можно сбросить к значениям по умолчанию, используя @specialize.

function example_function(@nospecialize x)
    ...
end

function example_function(@nospecialize(x = 1), y)
    ...
end

function example_function(x, y, z)
    @nospecialize x y
    ...
end

@nospecialize
f(y) = [x for x in y]
@specialize

Base.@specializeМакрос

@specialize

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

Base.gensymФункция

gensym([tag])

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

Base.@gensymМакрос

@gensym

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

Base.@gotoМакрос

@goto name

@goto name безусловный переход к оператору в позиции @label name.

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

Base.@labelМакрос

@label name

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

Base.SimdLoop.@simdМакрос

@simd

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

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

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

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

• Цикл должен быть внутренним циклом.
• Тело цикла должно быть кодом без ветвлений. Поэтому, @inbounds в настоящее время необходим для всех обращений к массивам. Компилятор иногда может преобразовать короткие &&, ||, и ?: выражения в код без ветвлений, если безопасно вычислить все операнды безусловно. Рассмотрите использование функции ifelse вместо ?: в цикле, если это безопасно.
• Доступы должны иметь шаблон шага и не могут быть «сборками» (чтения с произвольными индексами) или «разбросами» (записи с произвольными индексами).
• Шаг должен быть единичным.

• Не существует зависимостей памяти, связанных с циклом
• Ни одна итерация не ждёт предыдущую итерацию для продвижения вперёд.

Base.@pollyМакрос

@polly

Сообщает компилятору о применении полиэдрального оптимизатора Polly к функции.

Base.@generatedМакрос

@generated f
@generated(f)

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

См. Метапрограммирование для получения дополнительной информации.

Пример:

julia> @generated function bar(x)
           if x <: Integer
               return :(x ^ 2)
           else
               return :(x)
           end
       end
bar (generic function with 1 method)

julia> bar(4)
16

julia> bar("baz")
"baz"

Base.@pureМакрос

@pure ex
@pure(ex)

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

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

Base.@deprecateМакрос

@deprecate old new [ex=true]

Первый аргумент old - сигнатура устаревшего метода, второй new - вызов, который его заменяет. @deprecate экспортирует old, если необязательный третий аргумент false.

Примеры

julia> @deprecate old(x) new(x)
old (generic function with 1 method)

julia> @deprecate old(x) new(x) false
old (generic function with 1 method)

Пропущенные значения

Base.MissingТип

Missing

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

Base.missingКонстанта

missing

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

Base.coalesceФункция

coalesce(x, y...)

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

Примеры

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # returns `nothing`

julia> coalesce(missing, missing)
missing

Base.ismissingФункция

ismissing(x)

Указывает, является ли x missing.

Base.skipmissingФункция

skipmissing(itr)

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

Примеры

julia> x = skipmissing([1, missing, 2])
Base.SkipMissing{Array{Union{Missing, Int64},1}}(Union{Missing, Int64}[1, missing, 2])

julia> sum(x)
3

julia> x[1]
1

julia> x[2]
ERROR: MissingException: the value at index (2,) is missing
[...]

julia> argmax(x)
3

julia> collect(keys(x))
2-element Array{Int64,1}:
 1
 3

julia> collect(skipmissing([1, missing, 2]))
2-element Array{Int64,1}:
 1
 2

julia> collect(skipmissing([1 missing; 2 missing]))
2-element Array{Int64,1}:
 1
 2

Система

Base.runФункция

run(command, args...; wait::Bool = true)

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

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

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

Base.devnullКонстанта

devnull

Используется при перенаправлении потока для отбрасывания всех данных, записанных в него. По сути, эквивалентно /dev/null в Unix или NUL в Windows. Использование:

run(pipeline(`cat test.txt`, devnull))

Base.successФункция

success(command)

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

Base.process_runningФункция

process_running(p::Process)

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

Base.process_exitedФункция

process_exited(p::Process)

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

Base.killМетод

kill(p::Process, signum=SIGTERM)

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

Base.Sys.set_process_titleФункция

Sys.set_process_title(title::AbstractString)

Установите заголовок процесса. Нет действия на некоторых операционных системах.

Base.Sys.get_process_titleФункция

Sys.get_process_title()

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

Base.ignorestatusФункция

ignorestatus(command)

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

Base.detachФункция

detach(command)

Пометить объект команды так, чтобы он выполнялся в новой группе процессов, позволяя ему пережить процесс julia и не получать прерывания Ctrl-C.

Base.CmdТип

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)

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

• ignorestatus::Bool: Если true (по умолчанию false ), то объект Cmd не будет генерировать ошибку, если код возврата не равен нулю.
• detach::Bool: Если true (по умолчанию false ), то объект Cmd будет запущен в новой группе процессов, позволяя ему пережить процесс julia и не получать прерывания Ctrl-C.
• windows_verbatim::Bool: Если true (по умолчанию false ), то в Windows объект Cmd отправит строку командной строки в процесс без кавычек или экранирования аргументов, даже аргументов, содержащих пробелы. (В Windows аргументы передаются программе как одна строка "командной строки", и программы отвечают за её разбор на аргументы. По умолчанию, пустые аргументы и аргументы с пробелами или табуляцией заключаются в двойные кавычки ", а \, или " предваряются обратными слешами. windows_verbatim=true полезно для запуска программ, которые анализируют свою командную строку нестандартными способами.) Не оказывает влияния на системы, отличные от Windows.
• windows_hide::Bool: Если true (по умолчанию false ), то в Windows при выполнении Cmd новое окно консоли не отображается. Это не оказывает влияния, если консоль уже открыта или на системах, отличных от Windows.
• env: Установить переменные среды для использования при запуске Cmd. env это либо словарь, отображающий строки в строки, массив строк вида "var=val", массив или кортеж пар "var"=>val, или nothing. Для изменения (а не замены) существующей среды создайте env с помощью copy(ENV) и затем установите env["var"]=val как нужно.
• dir::AbstractString: Укажите рабочую директорию для команды (вместо текущей директории).

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

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)

Base.setenvФункция

setenv(command::Cmd, env; dir="")

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

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

Base.withenvФункция

withenv(f::Function, kv::Pair...)

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

Base.pipelineМетод

pipeline(from, to, ...)

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

Примеры:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))

Base.pipelineМетод

pipeline(command; stdin, stdout, stderr, append=false)

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

Примеры:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))

Base.Libc.gethostnameФункция

gethostname() -> AbstractString

Получить имя хоста локальной машины.

Base.Libc.getpidФункция

getpid(process) -> Int32

Получить идентификатор процесса-потомка, если он всё ещё существует.

getpid() -> Int32

Получить идентификатор процесса Julia.

Base.Libc.timeМетод

time()

Получить системное время в секундах с эпохи с достаточно высокой (обычно микросекундной) точностью.

Base.time_nsФункция

time_ns()

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

Base.@timeМакрос

@time

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

См. также @timev, @timed, @elapsed и @allocated.

julia> @time rand(10^6);
  0.001525 seconds (7 allocations: 7.630 MiB)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 seconds (8 allocations: 336 bytes)
2

Base.@timevМакрос

@timev

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

См. также @time, @timed, @elapsed и @allocated.

julia> @timev rand(10^6);
  0.001006 seconds (7 allocations: 7.630 MiB)
elapsed time (ns): 1005567
bytes allocated:   8000256
pool allocs:       6
malloc() calls:    1

Base.@timedМакрос

@timed

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

См. также @time, @timev, @elapsed и @allocated.

julia> val, t, bytes, gctime, memallocs = @timed rand(10^6);

julia> t
0.006634834

julia> bytes
8000256

julia> gctime
0.0055765

julia> fieldnames(typeof(memallocs))
(:allocd, :malloc, :realloc, :poolalloc, :bigalloc, :freecall, :total_time, :pause, :full_sweep)

julia> memallocs.total_time
5576500

Base.@elapsedМакрос

@elapsed

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

См. также @time, @timev, @timed и @allocated.

julia> @elapsed sleep(0.3)
0.301391426

Base.@allocatedМакрос

@allocated

Макрос для оценки выражения, отбрасывая результат и возвращая общее количество байтов, выделенных во время оценки выражения. Примечание: выражение оценивается внутри локальной функции, а не в текущем контексте, чтобы устранить влияние компиляции, однако всё же могут быть некоторые выделения памяти из-за JIT-компиляции. Это также делает результаты несовместимыми с макросами @time, которые не пытаются скорректировать влияние компиляции.

См. также @time, @timev, @timed и @elapsed.

julia> @allocated rand(10^6)
8000080

Base.EnvDictТип

EnvDict() -> EnvDict

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

Base.ENVКонстанта

ENV

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

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

Base.Sys.isunixФункция

Sys.isunix([os])

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

Base.Sys.isappleФункция

Sys.isapple([os])

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

Base.Sys.islinuxФункция

Sys.islinux([os])

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

Base.Sys.isbsdФункция

Sys.isbsd([os])

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

Base.Sys.isfreebsdФункция

Sys.isfreebsd([os])

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

Base.Sys.isopenbsdФункция

Sys.isopenbsd([os])

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

Base.Sys.isnetbsdФункция

Sys.isnetbsd([os])

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

Base.Sys.isdragonflyФункция

Sys.isdragonfly([os])

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

Base.Sys.iswindowsФункция

Sys.iswindows([os])

Предикат для проверки, является ли ОС производной от Microsoft Windows NT. См. документацию в Обработка различий в операционных системах.

Base.Sys.windows_versionФункция

Sys.windows_version()

Возвращает номер версии ядра Windows NT в формате VersionNumber, т.е. v"major.minor.build", или v"0.0.0" если система не Windows.

Base.Sys.free_memoryФункция

Sys.free_memory()

Возвращает общее количество свободной оперативной памяти в килобайтах.

Base.Sys.total_memoryФункция

Sys.total_memory()

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

Base.@staticМакрос

@static

Частичная оценка выражения во время разбора.

Например, @static Sys.iswindows() ? foo : bar будет вычислять Sys.iswindows() и вставлять либо foo либо bar в выражение. Это полезно в случаях, когда конструкция будет недействительной на других платформах, например, ccall для несуществующей функции. @static if Sys.isapple() foo end и @static foo <&&,||> bar также являются допустимым синтаксисом.

Версии

Base.VersionNumberТип

VersionNumber

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

Примеры

julia> VersionNumber("1.2.3")
v"1.2.3"

julia> VersionNumber("2.0.1-rc1")
v"2.0.1-rc1"

Base.@v_strМакрос

@v_str

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

Примеры

julia> v"1.2.3"
v"1.2.3"

julia> v"2.0.1-rc1"
v"2.0.1-rc1"

Ошибки

Base.errorФункция

error(message::AbstractString)

Вызывает ErrorException с заданным сообщением.

error(msg...)

Вызывает ErrorException с заданным сообщением.

Core.throwФункция

throw(e)

Выбрасывает объект в качестве исключения.

Base.rethrowФункция

rethrow([e])

Выбрасывает объект без изменения текущего стека отслеживания исключений. По умолчанию аргумент — текущее исключение (если вызов находится внутри блока catch).

Base.backtraceФункция

backtrace()

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

Base.catch_backtraceФункция

catch_backtrace()

Получить стек отслеживания текущего исключения для использования в блоках catch.

Base.catch_stackФункция

catch_stack(task=current_task(); [inclue_bt=true])

Получить стек исключений, которые в настоящее время обрабатываются. В случае вложенных блоков catch может быть более одного текущего исключения, в этом случае последнее выброшенное исключение находится в конце стека. Стек возвращается как вектор пар (exception,backtrace), или вектор исключений, если include_bt равно false.

Явное указание task вернёт текущий стек исключений для произвольной задачи. Это полезно для проверки задач, которые завершились из-за неперехваченных исключений.

Base.@assertМакрос

@assert cond [text]

Выбросить AssertionError, если cond равно false. Предпочтительный синтаксис для записи утверждений. Сообщение text необязательно отображается при ошибке утверждения.

Примеры

julia> @assert iseven(3) "3 is an odd number!"
ERROR: AssertionError: 3 is an odd number!

julia> @assert isodd(3) "What even are numbers?"

Core.ArgumentErrorТип

ArgumentError(msg)

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

Core.AssertionErrorТип

AssertionError([msg])

Утверждаемое условие не оценивается как true. Необязательный аргумент msg — это описательная строка ошибки.

Примеры

julia> @assert false "this is not true"
ERROR: AssertionError: this is not true

AssertionError обычно выбрасывается из @assert.

Core.BoundsErrorТип

BoundsError([a],[i])

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

Примеры

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: attempt to access 7-element Array{Float64,1} at index [8]
Stacktrace:
 [1] getindex(::Array{Float64,1}, ::Int64) at ./array.jl:660
 [2] top-level scope

julia> B = fill(1.0, (2,3));

julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Array{Float64,2} at index [2, 4]
Stacktrace:
 [1] getindex(::Array{Float64,2}, ::Int64, ::Int64) at ./array.jl:661
 [2] top-level scope

julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Array{Float64,2} at index [9]
Stacktrace:
 [1] getindex(::Array{Float64,2}, ::Int64) at ./array.jl:660
 [2] top-level scope

Base.CompositeExceptionТип

CompositeException

Обернуть Vector исключений, выброшенных задачей Task (например, сгенерированных от удалённого исполнителя через канал или асинхронно выполняемого локального I/O записи или удалённого исполнителя в pmap), с информацией о последовательности исключений. Например, если группа исполнителей выполняет несколько задач, и несколько исполнителей завершаются ошибкой, полученное CompositeException будет содержать «пакет» информации от каждого исполнителя, указывающий место и причину возникновения исключений.

Base.DimensionMismatchТип

DimensionMismatch([msg])

Вызываемые объекты не имеют совпадающих размерностей. Необязательный аргумент msg — это описательная строка ошибки.

Core.DivideErrorТип

DivideError()

Была попытка целочисленного деления на делитель с нулевым значением.

Примеры

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: integer division error
Stacktrace:
[...]

Core.DomainErrorТип

DomainError(val)
DomainError(val, msg)

Аргумент val функции или конструктора выходит за допустимую область.

Примеры

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]

Base.EOFErrorТип

EOFError()

Больше нет данных для чтения из файла или потока.

Core.ErrorExceptionТип

ErrorException(msg)

Общий тип ошибки. Сообщение об ошибке в поле .msg может предоставить более подробную информацию.

Примеры

julia> ex = ErrorException("I've done a bad thing");

julia> ex.msg
"I've done a bad thing"

Core.InexactErrorТип

InexactError(name::Symbol, T, val)

Невозможно точно преобразовать val в тип T в методе функции name.

Примеры

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]

Core.InterruptExceptionТип

InterruptException()

Процесс был остановлен прерыванием терминала (CTRL+C).

Base.KeyErrorТип

KeyError(key)

Операция индексирования в AbstractDict (Dict) или объекте типа Set пыталась получить доступ или удалить несуществующий элемент.

Core.LoadErrorТип

LoadError(file::AbstractString, line::Int, error)

Возникла ошибка при include, require или using файла. Подробности ошибки должны быть доступны в поле .error.

Core.MethodErrorТип

MethodError(f, args)

Метод с необходимой сигнатурой типа отсутствует в данной обобщенной функции. Либо нет уникального наиболее специфичного метода.

Base.MissingExceptionТип

MissingException(msg)

Исключение, выбрасываемое, когда значение missing встречается в ситуации, где оно не поддерживается. Сообщение об ошибке в поле msg может предоставить более подробные сведения.

Core.OutOfMemoryErrorТип

OutOfMemoryError()

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

Core.ReadOnlyMemoryErrorТип

ReadOnlyMemoryError()

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

Core.OverflowErrorТип

OverflowError(msg)

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

Base.ProcessFailedExceptionТип

ProcessFailedException

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

Core.StackOverflowErrorТип

StackOverflowError()

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

Base.SystemErrorТип

SystemError(prefix::AbstractString, [errno::Int32])

Системный вызов завершился с кодом ошибки (в глобальной переменной errno).

Core.TypeErrorТип

TypeError(func::Symbol, context::AbstractString, expected::Type, got)

Ошибка проверки типа или вызов встроенной функции с некорректным типом аргумента.

Core.UndefKeywordErrorТип

UndefKeywordError(var::Symbol)

Требуемый ключевой аргумент var не был присвоен в вызове функции.

Примеры

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
ERROR: UndefKeywordError: keyword argument my_arg not assigned
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] top-level scope at REPL[2]:1

Core.UndefRefErrorТип

UndefRefError()

Элемент или поле не определены для данного объекта.

Примеры

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: access to undefined reference
Stacktrace:
[...]

Core.UndefVarErrorТип

UndefVarError(var::Symbol)

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

Примеры

julia> a
ERROR: UndefVarError: a not defined

julia> a = 1;

julia> a
1

Base.StringIndexErrorТип

StringIndexError(str, i)

Возникла ошибка при попытке доступа к str по индексу i, который не является допустимым.

Core.InitErrorТип

InitError(mod::Symbol, error)

Возникла ошибка при выполнении функции __init__ модуля. Фактическая ошибка доступна в поле .error.

Base.retryФункция

retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

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

Примеры

retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, IOError))(io, 128; all=false)

Base.ExponentialBackOffТип

ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)

Итератор Float64 длиной n, элементы которого экспоненциально увеличиваются со скоростью в диапазоне factor * (1 ± jitter). Первый элемент — first_delay, и все элементы ограничены значением max_delay.

События

Base.TimerМетод

Timer(callback::Function, delay; interval = 0)

Создает таймер, который пробуждает задачи, ожидающие его (вызывая wait на объекте таймера) и вызывает функцию callback.

Ожидающие задачи пробуждаются, и функция callback вызывается после начальной задержки в delay секунды, а затем повторяется с заданным interval в секунды. Если interval равно 0, таймер срабатывает только один раз. Функция callback вызывается с единственным аргументом — самим таймером. Когда таймер закрыт (методом close), ожидающие задачи пробуждаются с ошибкой. Используйте isopen для проверки, активен ли таймер.

Примеры

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

julia> begin
           i = 0
           cb(timer) = (global i += 1; println(i))
           t = Timer(cb, 2, interval = 0.2)
           wait(t)
           sleep(0.5)
           close(t)
       end
1
2
3

Base.TimerТип

Timer(delay; interval = 0)

Создает таймер, который пробуждает задачи, ожидающие его (вызывая wait на объекте таймера).

Ожидающие задачи пробуждаются после начальной задержки в delay секунды, а затем повторяются с заданным interval в секунды. Если interval равно 0, таймер срабатывает только один раз. Когда таймер закрыт (методом close), ожидающие задачи пробуждаются с ошибкой. Используйте isopen для проверки, активен ли таймер.

Base.AsyncConditionТип

AsyncCondition()

Создает асинхронную условную переменную, которая пробуждает задачи, ожидающие ее (вызывая wait на объекте), когда уведомление приходит из C-кода через вызов uv_async_send. Ожидающие задачи пробуждаются с ошибкой, когда объект закрыт (методом close. Используйте isopen для проверки, активен ли объект.

Base.AsyncConditionМетод

AsyncCondition(callback::Function)

Создайте асинхронное условие, которое вызывает указанную callback функцию. callback передаётся один аргумент — сам объект асинхронного условия.

Рефлексия

Base.nameofМетод

nameof(m::Module) -> Symbol

Получить имя Module в виде Symbol.

Примеры

julia> nameof(Base.Broadcast)
:Broadcast

Base.parentmoduleФункция

parentmodule(m::Module) -> Module

Получить модуль, содержащий Module. Main — это сам модуль.

Примеры

julia> parentmodule(Main)
Main

julia> parentmodule(Base.Broadcast)
Base

parentmodule(t::DataType) -> Module

Определить модуль, содержащий определение (возможно, UnionAll-упакованного) DataType.

Примеры

julia> module Foo
           struct Int end
       end
Foo

julia> parentmodule(Int)
Core

julia> parentmodule(Foo.Int)
Foo

parentmodule(f::Function) -> Module

Определить модуль, содержащий (первое) определение обобщённой функции.

parentmodule(f::Function, types) -> Module

Определить модуль, содержащий заданное определение обобщённой функции.

Base.pathofМетод

pathof(m::Module)

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

Используйте dirname для получения каталога и basename для получения имени файла в пути.

Base.modulerootФункция

moduleroot(m::Module) -> Module

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

Base.@__MODULE__Макрос

@__MODULE__ -> Module

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

Base.fullnameФункция

fullname(m::Module)

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

Примеры

julia> fullname(Base.Iterators)
(:Base, :Iterators)

julia> fullname(Main)
(:Main,)

Base.namesФункция

names(x::Module; all::Bool = false, imported::Bool = false)

Получить массив имён, экспортированных из Module, исключая устаревшие. Если all равно true, то список также включает не экспортированные имена, определённые в модуле, устаревшие имена и имена, сгенерированные компилятором. Если imported равно true, то список также включает имена, явно импортированные из других модулей.

В качестве специального случая, все имена, определённые в Main, считаются "экспортированными", так как не принято явно экспортировать имена из Main.

Core.nfieldsФункция

nfields(x) -> Int

Получить количество полей в данном объекте.

Примеры

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

julia> ex = ErrorException("I've done a bad thing");

julia> nfields(ex)
1

В этих примерах, a — это Rational, у которого два поля. b — это Int, которая является примитивным битовым типом без полей. ex — это ErrorException, у которого одно поле.

Base.isconstФункция

isconst(m::Module, s::Symbol) -> Bool

Определить, является ли глобальная переменная const в данном Module.

Base.nameofМетод

nameof(f::Function) -> Symbol

Получить имя обобщённой Function в виде символа или :anonymous.

Base.functionlocМетод

functionloc(f::Function, types)

Возвращает кортеж (filename,line), содержащий местоположение определения обобщённой Function.

Base.functionlocМетод

functionloc(m::Method)

Возвращает кортеж (filename,line), содержащий местоположение определения Method.

Внутренности

Base.GC.gcФункция

GC.gc()

Выполнить сборку мусора.

Base.GC.enableФункция

GC.enable(on::Bool)

Управлять включением сборки мусора с помощью булевого аргумента (true для включения, false для выключения). Возвращает предыдущее состояние GC.

Base.GC.@preserveМакрос

GC.@preserve x1 x2 ... xn expr

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

Последний аргумент — это выражение, во время которого объекты будут сохранены. Предыдущие аргументы — это сохраняемые объекты.

Base.Meta.lowerФункция

lower(m, x)

Принимает выражение x и возвращает эквивалентное выражение в пониженном виде для выполнения в модуле m. См. также code_lowered.

Base.Meta.@lowerМакрос

@lower [m] x

Возвращает пониженную форму выражения x в модуле m. По умолчанию m — это модуль, в котором вызывается макрос. См. также lower.

Base.Meta.parseМетод

parse(str, start; greedy=true, raise=true, depwarn=true)

Разбирает строку выражения и возвращает выражение (которое можно позже передать eval для выполнения). start — это индекс первого символа для начала разбора. Если greedy равно true (по умолчанию), parse попытается прочитать весь входной текст; в противном случае, он остановится, как только обработает корректное выражение. Неполные, но синтаксически корректные выражения, вернут Expr(:incomplete, "(error message)"). Если raise равно true (по умолчанию), синтаксические ошибки, кроме неполных выражений, вызовут ошибку. Если raise равно false, parse вернёт выражение, которое при выполнении вызовет ошибку. Если depwarn равно false, предупреждения об устаревании будут подавлены.

julia> Meta.parse("x = 3, y = 5", 7)
(:(y = 5), 13)

julia> Meta.parse("x = 3, y = 5", 5)
(:((3, y) = 5), 13)

Base.Meta.parseМетод

parse(str; raise=true, depwarn=true)

Жадно разобрать строку выражения, вернув единственное выражение. Возникает ошибка, если после первого выражения есть дополнительные символы. Если raise равно true (по умолчанию), синтаксические ошибки приведут к ошибке; в противном случае parse вернёт выражение, которое вызовет ошибку при оценке. Если depwarn равно false, предупреждения об устаревании будут подавлены.

julia> Meta.parse("x = 3")
:(x = 3)

julia> Meta.parse("x = ")
:($(Expr(:incomplete, "incomplete: premature end of input")))

julia> Meta.parse("1.0.2")
ERROR: Base.Meta.ParseError("invalid numeric constant \"1.0.\"")
Stacktrace:
[...]

julia> Meta.parse("1.0.2"; raise = false)
:($(Expr(:error, "invalid numeric constant \"1.0.\"")))

Base.Meta.ParseErrorТип

ParseError(msg)

Выражение, переданное функции parse, не может быть интерпретировано как допустимое выражение Julia.

Base.macroexpandФункция

macroexpand(m::Module, x; recursive=true)

Взять выражение x и вернуть эквивалентное выражение со всеми макросами, удалёнными (расширенными), для выполнения в модуле m. Ключевое слово recursive управляет тем, расширяются ли более глубокие уровни вложенных макросов. Это показано в примере ниже:

julia> module M
           macro m1()
               42
           end
           macro m2()
               :(@m1())
           end
       end
M

julia> macroexpand(M, :(@m2()), recursive=true)
42

julia> macroexpand(M, :(@m2()), recursive=false)
:(#= REPL[16]:6 =# M.@m1)

Base.@macroexpandМакрос

@macroexpand

Вернуть эквивалентное выражение со всеми удалёнными (расширенными) макросами.

Существуют различия между @macroexpand и macroexpand.

• В то время как macroexpand принимает ключевой аргумент recursive, @macroexpand

всегда рекурсивен. Для нерекурсивной версии макроса см. @macroexpand1.

• В то время как macroexpand имеет явный аргумент module, @macroexpand всегда

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

julia> module M
           macro m()
               1
           end
           function f()
               (@macroexpand(@m),
                macroexpand(M, :(@m)),
                macroexpand(Main, :(@m))
               )
           end
       end
M

julia> macro m()
           2
       end
@m (macro with 1 method)

julia> M.f()
(1, 1, 2)

С @macroexpand выражение расширяется там, где @macroexpand появляется в коде (модуль M в примере). С macroexpand выражение расширяется в заданном в качестве первого аргумента модуле.

Base.@macroexpand1Макрос

@macroexpand1

Нерекурсивная версия @macroexpand.

Base.code_loweredФункция

code_lowered(f, types; generated=true, debuginfo=:default)

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

Если generated равно false, возвращаемые CodeInfo экземпляры будут соответствовать реализациям по умолчанию. Бросается ошибка, если реализация по умолчанию не существует. Если generated равно true, эти CodeInfo экземпляры будут соответствовать телам методов, полученным путём расширения генераторов.

Ключевое слово debuginfo управляет объёмом метаданных кода в выводе.

Обратите внимание, что будет выброшена ошибка, если types не являются типами листьев, когда generated равно true, и любой из соответствующих методов является методом @generated.

Base.code_typedФункция

code_typed(f, types; optimize=true, debuginfo=:default)

Возвращает массив пониженных форм (IR) с типом, выведенным по умолчанию, для методов, соответствующих заданной обобщённой функции и сигнатуре типа. Ключевой аргумент optimize управляет тем, применяются ли дополнительные оптимизации, такие как встраивание. Ключевое слово debuginfo управляет объёмом метаданных кода в выводе, возможные варианты — :source или :none.

Base.precompileФункция

precompile(f, args::Tuple{Vararg{Any}})

Компилирует заданную функцию f для кортежа аргументов (типов) args, но не выполняет её.