Основные элементы

exit(code=0)

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

atexit(f)

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

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

isinteractive() -> Bool

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

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

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

Ключевые аргументы

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

См. также sizeof.

Примеры

julia> Base.summarysize(1.0)
8

julia> Base.summarysize(Ref(rand(100)))
848

julia> sizeof(Ref(rand(100)))
8

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

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

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

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

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

Base.compilecache(module::PkgId)

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

__precompile__(isprecompilable::Bool)

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

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

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

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

include([mapexpr::Function,] path::AbstractString)

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

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

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

include_string([mapexpr::Function,] m::Module, code::AbstractString, filename::AbstractString="string")

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

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

include_dependency(path::AbstractString)

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

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

which(f, types)

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

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

См. также: parentmodule и @which и @edit в InteractiveUtils.

methods(f, [types], [module])

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

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

См. также: which и @which.

@show exs...

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

См. также: show, @info, println.

Примеры

julia> x = @show 1+2
1 + 2 = 3
3

julia> @show x^2 x/2;
x ^ 2 = 9
x / 2 = 1.5

ans

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

active_project()

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

set_active_project(projfile::Union{AbstractString,Nothing})

Устанавливает активный файл Project.toml на projfile. См. также Base.active_project.

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 используется внутри модулей для указания Julia, какие функции должны быть доступны пользователю. Например: export foo делает имя foo доступным при using модуля. Подробности см. в разделе руководства о модулях.

import

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

using

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

baremodule

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

module Mod

...

end

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

baremodule Mod

using Base

eval(x) = Core.eval(Mod, x)
include(p) = Base.include(Mod, p)

...

end

function

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

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

Или с использованием короткой записи:

add(a, b) = a + b

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

macro

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

Примеры

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

julia> @sayhello "Charlie"
Hello, Charlie!

julia> macro saylots(x...)
           return :( println("Say: ", $(x...)) )
       end
@saylots (macro with 1 method)

julia> @saylots "hey " "there " "friend"
Say: hey there friend

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

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

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...end обозначает блок кода.

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

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

begin также может использоваться при индексировании для представления первого индекса коллекции или первого индекса размерности массива.

Примеры

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

julia> A[begin, :]
2-element Array{Int64,1}:
 1
 2

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 var1 = value1, var2, var3 = value3
    code
end

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

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.

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

julia> if 1 end
ERROR: TypeError: non-boolean (Int64) used in boolean context

for

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

Примеры

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

while

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

Примеры

julia> i = 1
1

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

break

Немедленно прервать цикл.

Примеры

julia> i = 0
0

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

continue

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

Примеры

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

try/catch

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

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

или, когда файл не может быть прочитан в переменную:

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "File not found."
end

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

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

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 создаёт несколько объектов выражения в блоке без использования явного конструктора Expr. Например:

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

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

local

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

Примеры

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 x заставляет x в текущей области видимости и её внутренних областях видимости ссылаться на глобальную переменную с таким же именем. Для получения дополнительной информации см. раздел руководства по области видимости переменных.

Примеры

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 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

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

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 похож на struct, но также позволяет устанавливать поля типа после создания. Для получения дополнительной информации см. раздел руководства по Составным типам.

abstract type

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

abstract type Number end
abstract type Real <: Number end

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

primitive type

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

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

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

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 подавляет вывод результата этого выражения.

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

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

В стандартном 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!"

julia> function plot(x, y; style="solid", width=1, color="black")
           ###
       end

julia> [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> ; # upon typing ;, the prompt changes (in place) to: shell>
shell> echo hello
hello

=

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

• Для переменной 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

a ? b : c

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

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

Более подробную информацию см. в разделе руководства по потоку управления.

Примеры

julia> x = 1; y = 2;

julia> x > y ? println("x is larger") : println("y is larger")
y is larger

Main

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

julia> @__MODULE__
Main

Core

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

Base

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

Base.Broadcast

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

Docs

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

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

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

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

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

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

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

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

Base.GC

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

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

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

Примеры

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

julia> a == b
true

julia> a === b
false

julia> a === a
true

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

isequal(x, y)

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

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

Реализация

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

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

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

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

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

Примеры

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

julia> missing == missing
missing

julia> isequal(missing, missing)
true

isequal(x)

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

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

isless(x, y)

Проверить, является ли x меньше y, согласно фиксированному полному порядку (определенному совместно с isequal). 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. Типы с частичным порядком должны реализовывать <. Обратитесь к документации по Альтернативным порядка для определения методов альтернативного порядка, которые могут быть использованы в сортировке и связанных функциях.

Примеры

julia> isless(1, 3)
true

julia> isless("Red", "Blue")
false

ifelse(condition::Bool, x, y)

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

Примеры

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

typeassert(x, type)

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

Примеры

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

typeof(x)

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

См. также eltype.

Примеры

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

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

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

tuple(xs...)

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

См. также Tuple, NamedTuple.

Примеры

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

julia> ans === (1, 'b', π)
true

julia> Tuple(Real[1, 2, pi])  # takes a collection
(1, 2, π)

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

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

Примеры

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

ntuple(f, ::Val{N})

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

Примеры

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

objectid(x) -> UInt

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

См. также hash, IdDict.

hash(x[, h::UInt]) -> UInt

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

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

См. также: objectid, Dict, Set.

finalizer(f, x)

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

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

Примеры

finalizer(my_mutable_struct) do x
    @async println("Finalizing $x.")
end

finalizer(my_mutable_struct) do x
    ccall(:jl_safe_printf, Cvoid, (Cstring, Cstring), "Finalizing %s.", repr(x))
end

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

Пример

mutable struct MyMutableStruct
    bar
    function MyMutableStruct(bar)
        x = new(bar)
        f(t) = @async println("Finalizing $t.")
        finalizer(f, x)
    end
end

finalize(x)

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

copy(x)

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

См. также copy!, copyto!.

deepcopy(x)

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

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

getproperty(value, name::Symbol)
getproperty(value, name::Symbol, order::Symbol)

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

Примеры

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

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

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

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

См. также setfield!, propertynames и getproperty.

propertynames(x, private=false)

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

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

См. также: hasproperty, hasfield.

hasproperty(x, s::Symbol)

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

См. также: propertynames, hasfield.

getfield(value, name::Symbol, [order::Symbol])
getfield(value, i::Int, [order::Symbol])

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

Примеры

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

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1

setfield!(value, name::Symbol, x, [order::Symbol])
setfield!(value, i::Int, x, [order::Symbol])

Присвойте x именованному полю в value составного типа. value должен быть изменяемым, а x должен быть подтипом fieldtype(typeof(value), name). Кроме того, для этой операции может быть указан порядок. Если поле было объявлено @atomic, эта спецификация обязательна. В противном случае, если поле не объявлено @atomic, оно должно быть :not_atomic при указании. См. также 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

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

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

Для проверки определения элемента массива используйте 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

@isdefined s -> Bool

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

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

Примеры

julia> @isdefined newvar
false

julia> newvar = 1
1

julia> @isdefined newvar
true

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

julia> f()
false
true

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, то функция вернёт значение, наиболее близкое к x и представимое типом T.

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

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

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

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

julia> y === x
true

См. также: round, trunc, oftype, reinterpret.

promote(xs...)

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

См. также: [promote_type], [promote_rule].

Примеры

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

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

widen(x)

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

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

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

Примеры

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

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

См. также: one, oneunit и LinearAlgebra's I.

Примеры

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

supertype(T::DataType)

Возвращает супертип типа T.

Примеры

julia> supertype(Int32)
Signed

Core.Type{T}

Core.Type — это абстрактный тип, содержащий все типы объектов. Единственным экземпляром типа-сингултона Core.Type{T} является объект T.

Примеры

julia> isa(Type{Float64}, Type)
true

julia> isa(Float64, Type)
true

julia> isa(Real, Type{Float64})
false

julia> isa(Real, Type{Real})
true

DataType <: Type{T}

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

Примеры

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

<:(T1, T2)

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

Примеры

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

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

>:(T1, T2)

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

typejoin(T, S)

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

typeintersect(T::Type, S::Type)

Вычислить тип, содержащий пересечение T и S. Обычно это будет наименьший такой тип или тип, близкий к нему.

promote_type(type1, type2)

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

См. также: promote, promote_typejoin, promote_rule.

Примеры

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

promote_rule(type1, type2)

Указывает, какой тип следует использовать promote, когда заданы значения типов type1 и type2. Эту функцию не следует вызывать напрямую, но необходимо добавлять к ней определения для новых типов по мере необходимости.

promote_typejoin(T, S)

Вычислить тип, который содержит как T , так и S, который может быть родителем обоих типов или Union при необходимости. Возвращает к typejoin.

См. вместо этого promote, promote_type.

Примеры

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64

isdispatchtuple(T)

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

ismutable(v) -> Bool

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

См. также isbits, isstructtype.

Примеры

julia> ismutable(1)
false

julia> ismutable([1,2])
true

isimmutable(v) -> Bool

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

Примеры

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

isabstracttype(T)

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

Примеры

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

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

Base.issingletontype(T)

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

isstructtype(T) -> Bool

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

nameof(t::DataType) -> Symbol

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

Примеры

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

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

fieldnames(x::DataType)

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

См. также propertynames, hasfield.

Примеры

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

julia> fieldnames(typeof(1+im))
(:re, :im)

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

Получение имени поля i DataType.

Примеры

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

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

fieldtypes(T::Type)

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

Примеры

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

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

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

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

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

См. также fieldnames, fieldcount, hasproperty.

Примеры

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false

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, у которой одно поле.

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

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

isconst(t::DataType, s::Union{Int,Symbol}) -> Bool

Определение, является ли поле s объявлено const в данном типе t.

sizeof(T::DataType)
sizeof(obj)

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

См. также summarysize.

Примеры

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof(collect(1.0:10.0))
80

Если DataType T не имеет определённого размера, будет выброшено исключение.

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

isconcretetype(T)

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

См. также: isbits, isabstracttype, issingletontype.

Примеры

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

isbits(x)

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

isbitstype(T)

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

См. также isbits, isprimitivetype, ismutable.

Примеры

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

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)
13-element Vector{Tuple{UInt64, Symbol, Type}}:
 (0x0000000000000000, :desc, Union{RawFD, String})
 (0x0000000000000008, :device, UInt64)
 (0x0000000000000010, :inode, UInt64)
 (0x0000000000000018, :mode, UInt64)
 (0x0000000000000020, :nlink, Int64)
 (0x0000000000000028, :uid, UInt64)
 (0x0000000000000030, :gid, UInt64)
 (0x0000000000000038, :rdev, UInt64)
 (0x0000000000000040, :size, Int64)
 (0x0000000000000048, :blksize, Int64)
 (0x0000000000000050, :blocks, Int64)
 (0x0000000000000058, :mtime, Float64)
 (0x0000000000000060, :ctime, Float64)

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

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

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

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

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

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

typemin(T)

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

Примеры

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

typemax(T)

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

См. также: floatmax, typemin, eps.

Примеры

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> floatmax(Float32)  # largest finite floating point number
3.4028235f38

floatmin(T = Float64)

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

Примеры

julia> floatmin(Float16)
Float16(6.104e-5)

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T = Float64)

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

См. также: typemax, floatmin, eps.

Примеры

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf

maxintfloat(T=Float64)

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

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

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

maxintfloat(T, S)

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

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

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$, то

\[|y-x| \leq \operatorname{eps}(x)/2.\]

См. также: nextfloat, issubnormal, floatmax.

Примеры

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

instances(T::Type)

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

Пример

julia> @enum Color red blue green

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

Any::DataType

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

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 a value of type Float64

Union{}

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

Примеры

julia> isa(nothing, Union{})
false

UnionAll

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

Примеры

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

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

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

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

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

NTuple{N, T}

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

Примеры

julia> isa((1, 2, 3, 4, 5, 6), NTuple{6, Int})
true

NamedTuple

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

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

Макрос @NamedTuple может использоваться для удобного объявления типов NamedTuple.

Примеры

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

julia> x.a
1

julia> x[:a]
1

julia> x[(:a,)]
(a = 1,)

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

julia> values(x)
(1, 2)

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

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

Подобно тому, как можно программно определить ключевые аргументы, именованный кортеж можно создать, задав пару name::Symbol => value или используя оператор splatting (распространения) для итератора, возвращающего такие пары после точки с запятой внутри литерала кортежа:

julia> (; :a => 1)
(a = 1,)

julia> keys = (:a, :b, :c); values = (1, 2, 3);

julia> (; zip(keys, values)...)
(a = 1, b = 2, c = 3)

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

julia> x = 0
0

julia> t = (; x)
(x = 0,)

julia> (; t.x)
(x = 0,)

@NamedTuple{key1::Type1, key2::Type2, ...}
@NamedTuple begin key1::Type1; key2::Type2; ...; end

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

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

julia> @NamedTuple{a::Float64, b::String}
NamedTuple{(:a, :b), Tuple{Float64, String}}

julia> @NamedTuple begin
           a::Float64
           b::String
       end
NamedTuple{(:a, :b), Tuple{Float64, String}}

Val(c)

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

Примеры

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"

Vararg{T,N}

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

См. также NTuple.

Примеры

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

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

Nothing

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

См. также: isnothing, Some, Missing.

isnothing(x)

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

См. также something, notnothing, ismissing.

notnothing(x)

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

Some{T}

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

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

something(x...)

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

См. также coalesce, skipmissing, @something.

Примеры

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

@something(x...)

Короткий вариант something.

Примеры

julia> f(x) = (println("f($x)"); nothing);

julia> a = 1;

julia> a = @something a f(2) f(3) error("Unable to find default for `a`")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("Unable to find default for `b`")
f(2)
f(3)
ERROR: Unable to find default for `b`
[...]

julia> b = @something b f(2) f(3) Some(nothing)
f(2)
f(3)

julia> b === nothing
true

Enum{T<:Integer}

Абстрактный базовый тип для всех перечисленных типов, определённых с помощью @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 автоматически выполняют эти преобразования. В случае, если перечисление создано с нестандартным BaseType, Integer(value1) вернёт целое число value1 типа BaseType.

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

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

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

Symbol

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

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

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

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

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

Symbol(x...) -> Symbol

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

Примеры

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

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

Module

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

Module(name::Symbol=:anonymous, std_imports=true, default_names=true)

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

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

Function

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

Примеры

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (singleton type of function sin, subtype of Function)

julia> ans <: Function
true

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

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

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

См. также applicable.

Примеры

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

julia> f(; oranges=0) = oranges;

julia> hasmethod(f, Tuple{}, (:oranges,))
true

julia> hasmethod(f, Tuple{}, (:apples, :bananas))
false

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

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

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

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

См. также hasmethod.

Примеры

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

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

Base.isambiguous(m1, m2; ambiguous_bottom=false) -> Bool

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

Для параметрических типов аргумент ambiguous_bottom управляет тем, считается ли Union{} неоднозначным пересечением параметров типов. Если true, то это пересечение считается неоднозначным, в противном случае (false) — нет.

Примеры

julia> foo(x::Complex{<:Integer}) = 1
foo (generic function with 1 method)

julia> foo(x::Complex{<:Rational}) = 2
foo (generic function with 2 methods)

julia> m1, m2 = collect(methods(foo));

julia> typeintersect(m1.sig, m2.sig)
Tuple{typeof(foo), Complex{Union{}}}

julia> Base.isambiguous(m1, m2, ambiguous_bottom=true)
true

julia> Base.isambiguous(m1, m2, ambiguous_bottom=false)
false

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

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

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

Примеры

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

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

julia> f(2)
5

julia> f1(::Integer) = Integer
       f1(::Real) = Real;

julia> f2(x::Real) = _f2(x)
       _f2(::Integer) = Integer
       _f2(_) = Real;

julia> f1(1)
Integer

julia> f2(1)
Integer

julia> invoke(f1, Tuple{Real}, 1)
Real

julia> invoke(f2, Tuple{Real}, 1)
Integer

@invoke f(arg::T, ...; kwargs...)

Предоставляет удобный способ вызова invoke; @invoke f(arg1::T1, arg2::T2; kwargs...) будет раскрыт в invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...). Когда аннотация типа аргумента опущена, она задаётся как аргумент Any, например @invoke f(arg1::T, arg2) будет раскрыт в invoke(f, Tuple{T,Any}, arg1, arg2).

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

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

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

Предоставляет удобный способ вызова Base.invokelatest. @invokelatest f(args...; kwargs...) будет просто раскрыт в Base.invokelatest(f, args...; kwargs...).

new, or new{A,B,...}

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

|>(x, f)

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

Примеры

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

f ∘ g

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

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

Примеры

julia> map(uppercase∘first, ["apple", "banana", "carrot"])
3-element Vector{Char}:
 'A': ASCII/Unicode U+0041 (category Lu: Letter, uppercase)
 'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)
 'C': ASCII/Unicode U+0043 (category Lu: Letter, uppercase)

julia> fs = [
           x -> 2x
           x -> x/2
           x -> x-1
           x -> x+1
       ];

julia> ∘(fs...)(3)
3.0

См. также ComposedFunction, !f::Function.

ComposedFunction{Outer,Inner} <: Function

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

ComposedFunction(outer, inner)(args...; kw...) === outer(inner(args...; kw...))

Предпочтительный способ создания экземпляра ComposedFunction — использование оператора композиции ∘:

julia> sin ∘ cos === ComposedFunction(sin, cos)
true

julia> typeof(sin∘cos)
ComposedFunction{typeof(sin), typeof(cos)}

Составные части хранятся в полях ComposedFunction и могут быть получены следующим образом:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true

См. также ∘.

splat(f)

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

    splat(f) = args->f(args...)

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

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

julia> map(Base.splat(+), zip(1:3,4:6))
3-element Vector{Int64}:
 5
 7
 9

Fix1(f, x)

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

См. также Fix2.

Fix2(f, x)

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

Core.eval(m::Module, expr)

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

eval(expr)

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

@eval [mod,] ex

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

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

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

esc(e)

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

@inbounds(blk)

Убирает проверку границ массива в выражениях.

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

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

@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]"

@propagate_inbounds

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

@inline

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

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

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

# annotate long-form definition
@inline function longdef(x)
    ...
end

# annotate short-form definition
@inline shortdef(x) = ...

# annotate anonymous function that a `do` block creates
f() do
    @inline
    ...
end

@inline block

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

# The compiler will try to inline `f`
@inline f(...)

# The compiler will try to inline `f`, `g` and `+`
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # body
end

let
    @inline explicit_noinline(args...) # will be inlined
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # the compiler will try to inline this call
    b = f(b0)          # the compiler will NOT try to inline this call
    return a, b
end

@noinline

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

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

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

# annotate long-form definition
@noinline function longdef(x)
    ...
end

# annotate short-form definition
@noinline shortdef(x) = ...

# annotate anonymous function that a `do` block creates
f() do
    @noinline
    ...
end

@noinline block

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

# The compiler will try to not inline `f`
@noinline f(...)

# The compiler will try to not inline `f`, `g` and `+`
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # body
end

let
    @noinline explicit_inline(args...) # will not be inlined
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # the compiler will NOT try to inline this call
    b = f(b0)            # the compiler will try to inline this call
    return a, b
end

@nospecialize

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

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

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

function example_function(@nospecialize x)
    ...
end

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

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

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

@specialize

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

gensym([tag])

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

@gensym

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

var

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

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

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

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

@goto name

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

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

@label name

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

@simd

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

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

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

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

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

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

@polly

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

@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"

@pure ex

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

@assume_effects setting... ex

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

julia> Base.@assume_effects :terminates_locally function pow(x)
           # this :terminates_locally allows `pow` to be constant-folded
           res = 1
           1 < x < 20 || error("bad pow")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
pow (generic function with 1 method)

julia> code_typed() do
           pow(12)
       end
1-element Vector{Any}:
 CodeInfo(
1 ─     return 479001600
) => Int64

julia> Base.@assume_effects :total !:nothrow @ccall jl_type_intersection(Vector{Int}::Any, Vector{<:Integer}::Any)::Any
Vector{Int64} (alias for Array{Int64, 1})

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

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

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :terminates_locally
• :foldable
• :total

Расширенная помощь

:consistent

Настройка :consistent утверждает, что для одинаковых (===) входных данных:

• Способ завершения (значение возврата, исключение, незавершенность) всегда будет одинаковым.
• Если метод возвращает значение, результаты всегда будут одинаковыми.

:effect_free

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

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

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

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

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

:nothrow

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

:terminates_globally

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

:terminates_locally

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

:foldable

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

• :consistent
• :effect_free
• :terminates_globally

:total

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

• :consistent
• :effect_free
• :nothrow
• :terminates_globally

Отрицаемые эффекты

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

Сравнение с @pure

@assume_effects :foldable подобен @pure с основным отличием, что требование :consistent-cy применяется к миру в целом, а не глобально, как описано выше. Однако, в частности, метод, помеченный @pure, всегда должен быть по крайней мере :foldable. Другое преимущество заключается в том, что эффекты, введенные @assume_effects, распространяются на вызывающие стороны межпроцедурно, в то время как чистота, определенная @pure, нет.

@deprecate old new [export_old=true]

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

Примеры

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)

Missing

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

См. также: skipmissing, nonmissingtype, Nothing.

missing

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

См. также: NaN, skipmissing, nonmissingtype.

coalesce(x...)

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

См. также skipmissing, something, @coalesce.

Примеры

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

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

julia> coalesce(missing, missing)
missing

@coalesce(x...)

Короткая версия функции coalesce.

Примеры

julia> f(x) = (println("f($x)"); missing);

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` is still missing")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` is still missing")
f(2)
f(3)
ERROR: `b` is still missing
[...]

ismissing(x)

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

См. также: skipmissing, isnothing, isnan.

skipmissing(itr)

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

Используйте collect, чтобы получить Array, содержащий значения, отличные от missing в itr.

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

См. также coalesce, ismissing, something.

Примеры

julia> x = skipmissing([1, missing, 2])
skipmissing(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 Vector{Int64}:
 1
 3

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

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

nonmissingtype(T::Type)

Если T является объединением типов, содержащих Missing, возвращает новый тип без Missing.

Примеры

julia> nonmissingtype(Union{Int64,Missing})
Int64

julia> nonmissingtype(Any)
Any

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

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

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

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

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

devnull

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

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

success(command)

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

process_running(p::Process)

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

process_exited(p::Process)

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

kill(p::Process, signum=Base.SIGTERM)

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

Sys.set_process_title(title::AbstractString)

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

Sys.get_process_title()

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

ignorestatus(command)

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

detach(command)

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

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. Для изменения (а не замены) существующей среды инициализируйте env с помощью copy(ENV) и затем установите env["var"]=val как нужно. Для добавления в блок среды внутри объекта Cmd без замены всех элементов используйте addenv(), который вернёт объект Cmd с обновлённой средой.
• dir::AbstractString: Укажите рабочую директорию для команды (вместо текущей директории).

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

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

setenv(command::Cmd, env; dir)

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

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

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

addenv(command::Cmd, env...; inherit::Bool = true)

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

См. также Cmd, setenv, ENV.

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

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

setcpuaffinity(original_command::Cmd, cpus) -> command::Cmd

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

Эта функция поддерживается только в Linux и Windows. Она не поддерживается в macOS, потому что libuv не поддерживает установку аффинити.

Примеры

В Linux программа командной строки taskset может использоваться для демонстрации работы setcpuaffinity.

julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13

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

julia> 0b010011
0x13

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`))

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

Перенаправьте ввод/вывод к или из заданного command. Ключевые аргументы задают, какие потоки команды должны быть перенаправлены. append управляет тем, добавляется ли вывод файла к файлу. Это более общая версия функции pipeline с двумя аргументами. 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))

gethostname() -> AbstractString

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

getpid() -> Int32

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

getpid(process) -> Int32

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

time()

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

time_ns()

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

@time expr
@time "description" expr

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

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

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

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

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 seconds (2.19 M allocations: 116.555 MiB, 3.75% gc time, 99.94% compilation time)

julia> @time x * x;
  0.000009 seconds (1 allocation: 896 bytes)

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

julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 seconds (5 allocations: 144 bytes)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 seconds (5 allocations: 144 bytes)
2: 1.001263 seconds (5 allocations: 144 bytes)
3: 1.003676 seconds (5 allocations: 144 bytes)

@showtime expr

Как @time, но также выводит оцениваемое выражение для справки.

См. также @time.

julia> @showtime sleep(1)
sleep(1): 1.002164 seconds (4 allocations: 128 bytes)

@timev expr
@timev "description" expr

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

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

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

julia> x = rand(10,10);

julia> @timev x * x;
  0.546770 seconds (2.20 M allocations: 116.632 MiB, 4.23% gc time, 99.94% compilation time)
elapsed time (ns): 546769547
gc time (ns):      23115606
bytes allocated:   122297811
pool allocs:       2197930
non-pool GC allocs:1327
malloc() calls:    36
realloc() calls:   5
GC pauses:         3

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1

@timed

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

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

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

julia> stats = @timed rand(10^6);

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

julia> propertynames(stats.gcstats)
(:allocd, :malloc, :realloc, :poolalloc, :bigalloc, :freecall, :total_time, :pause, :full_sweep)

julia> stats.gcstats.total_time
5576500

@elapsed

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

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

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

julia> @elapsed sleep(0.3)
0.301391426

@allocated

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

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

julia> @allocated rand(10^6)
8000080

EnvDict() -> EnvDict

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

ENV

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

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

Sys.isunix([os])

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

Sys.isapple([os])

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

Sys.islinux([os])

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

Sys.isbsd([os])

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

Sys.isfreebsd([os])

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

Sys.isopenbsd([os])

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

Sys.isnetbsd([os])

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

Sys.isdragonfly([os])

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

Sys.iswindows([os])

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

Sys.windows_version()

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

Sys.free_memory()

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

Sys.total_memory()

Получить общее количество оперативной памяти (включая используемую в данный момент) в байтах. Это значение может быть ограничено, например, группами управления Linux. Для неограниченного значения см. Sys.physical_memory().

Sys.free_physical_memory()

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

Sys.total_physical_memory()

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

@static

Частично вычисляет выражение во время парсинга.

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

VersionNumber

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

VersionNumber объекты могут быть сравнены со всеми стандартными операторами сравнения (==, <, <=, и т.д.), а результат следует правилам semver.

См. также @v_str для эффективного построения VersionNumber объектов из строковых литералов в формате semver, VERSION для VersionNumber самой Julia, и Литералы Номеров Версий в руководстве.

Примеры

julia> a = VersionNumber(1, 2, 3)
v"1.2.3"

julia> a >= v"1.2"
true

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

julia> b >= v"2.0.1"
false

@v_str

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

Примеры

julia> v"1.2.3"
v"1.2.3"

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

error(message::AbstractString)

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

error(msg...)

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

throw(e)

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

См. также: rethrow, error.

rethrow()

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

backtrace()

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

catch_backtrace()

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

current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

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

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

@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?"

Experimental.register_error_hint(handler, exceptiontype)

Зарегистрировать функцию «подсказки» handler(io, exception), которая может предложить возможные способы для пользователей обойти ошибки. handler должна проверить exception на предмет соответствия условиям для выдачи подсказки и, если они выполнены, сгенерировать вывод в io. Пакеты должны вызывать register_error_hint изнутри своей функции __init__.

Для определённых типов исключений handler должна принимать дополнительные аргументы:

• MethodError: предоставить handler(io, exc::MethodError, argtypes, kwargs), которая разделяет объединённые аргументы на позиционные и ключевые.

При выводе подсказки вывод обычно должен начинаться с \n.

Если вы определяете пользовательские типы исключений, ваш метод showerror может поддерживать подсказки, вызывая Experimental.show_error_hints.

Пример

julia> module Hinter

       only_int(x::Int)      = 1
       any_number(x::Number) = 2

       function __init__()
           Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
               if exc.f == only_int
                    # Color is not necessary, this is just to show it's possible.
                    print(io, "\nDid you mean to call ")
                    printstyled(io, "`any_number`?", color=:cyan)
               end
           end
       end

       end

Затем, если вы вызываете Hinter.only_int на объекте, который не является Int (что вызывает MethodError), она выводит подсказку:

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
Did you mean to call `any_number`?
Closest candidates are:
    ...

Experimental.show_error_hints(io, ex, args...)

Вызовите все обработчики из Experimental.register_error_hint для конкретного типа исключения typeof(ex). args должен содержать все другие аргументы, ожидаемые обработчиком для этого типа.

ArgumentError(msg)

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

AssertionError([msg])

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

Примеры

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

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

BoundsError([a],[i])

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

Примеры

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: attempt to access 7-element Vector{Float64} at index [8]


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

julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [2, 4]


julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [9]

CompositeException

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

DimensionMismatch([msg])

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

DivideError()

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

Примеры

julia> 2/0
Inf

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

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:
[...]

EOFError()

Доступные данные для чтения из файла или потока закончились.

ErrorException(msg)

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

Примеры

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

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

InexactError(name::Symbol, T, val)

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

Примеры

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

InterruptException()

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

Обратите внимание, что в сценарии Julia, запущенном без опции -i (интерактивный), InterruptException по умолчанию не выбрасывается. Вызов Base.exit_on_sigint(false) в сценарии может восстановить поведение REPL. В качестве альтернативы, сценарий Julia можно запустить с

julia -e "include(popfirst!(ARGS))" script.jl

чтобы позволить InterruptException быть вызванным при нажатии CTRL+C во время выполнения.

KeyError(key)

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

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

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

MethodError(f, args)

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

MissingException(msg)

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

OutOfMemoryError()

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

ReadOnlyMemoryError()

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

OverflowError(msg)

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

ProcessFailedException

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

StackOverflowError()

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

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

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

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

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

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

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:
[...]

UndefVarError(var::Symbol)

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

Примеры

julia> a
ERROR: UndefVarError: a not defined

julia> a = 1;

julia> a
1

StringIndexError(str, i)

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

InitError(mod::Symbol, error)

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

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)

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.

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

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

Задачи ожидания пробуждаются, и функция callback вызывается после начальной задержки delay секунд, а затем повторяется с заданным интервалом interval секунд. Если interval равно 0, обратный вызов выполняется только один раз. Функция callback вызывается с одним аргументом - самим таймером. Останавливает таймер путем вызова close . cb может быть выполнено один раз в конце, если таймер уже истек.

Примеры

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

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

Timer(delay; interval = 0)

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

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

AsyncCondition()

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

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

AsyncCondition(callback::Function)

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

nameof(m::Module) -> Symbol

Получить имя Module как Symbol.

Примеры

julia> nameof(Base.Broadcast)
:Broadcast

parentmodule(m::Module) -> Module

Получить модуль, окружающий Module. Модуль сам является своим родительским модулем.

См. также: names, nameof, fullname, @__MODULE__.

Примеры

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

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

pathof(m::Module)

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

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

pkgdir(m::Module[, paths::String...])

Возвращает корневую директорию пакета, который импортировал модуль m, или nothing если m не был импортирован из пакета. Дополнительно можно указать компоненты пути, чтобы получить путь внутри корневой директории пакета.

julia> pkgdir(Foo)
"/path/to/Foo.jl"

julia> pkgdir(Foo, "src", "file.jl")
"/path/to/Foo.jl/src/file.jl"

moduleroot(m::Module) -> Module

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

__module__

Аргумент __module__ виден только внутри макроса и предоставляет информацию (в виде объекта Module) о контексте расширения вызова макроса. См. раздел руководства по вызову макроса для получения дополнительной информации.

__source__

Аргумент __source__ виден только внутри макроса и предоставляет информацию (в виде объекта LineNumberNode) о расположении в парсере символа @ вызова макроса. См. раздел руководства по вызову макроса для получения дополнительной информации.

@__MODULE__ -> Module

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

@__FILE__ -> AbstractString

Расширяется до строки с путём к файлу, содержащему вызов макроса, или пустой строкой, если вычисление происходит внутри julia -e <expr>. Возвращает nothing, если у макроса отсутствует информация о источнике парсера. Или см. PROGRAM_FILE.

@__DIR__ -> AbstractString

Расширяется до строки с абсолютным путём к директории файла, содержащего вызов макроса. Возвращает текущую рабочую директорию, если выполняется из REPL или вычисление происходит внутри julia -e <expr>.

@__LINE__ -> Int

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

fullname(m::Module)

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

Примеры

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

julia> fullname(Main)
(:Main,)

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

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

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

См. также: @locals, @__MODULE__.

nameof(f::Function) -> Symbol

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

functionloc(f::Function, types)

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

functionloc(m::Method)

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

@locals()

Создаёт словарь имён (как символы) и значений всех локальных переменных, определённых на момент вызова.

Примеры

julia> let x = 1, y = 2
           Base.@locals
       end
Dict{Symbol, Any} with 2 entries:
  :y => 2
  :x => 1

julia> function f(x)
           local y
           show(Base.@locals); println()
           for i = 1:1
               show(Base.@locals); println()
           end
           y = 2
           show(Base.@locals); println()
           nothing
       end;

julia> f(42)
Dict{Symbol, Any}(:x => 42)
Dict{Symbol, Any}(:i => 1, :x => 42)
Dict{Symbol, Any}(:y => 2, :x => 42)

GC.gc([full=true])

Выполняет сборку мусора. Аргумент full определяет тип сбора: полный сбор (по умолчанию) сканирует все объекты, что делает следующий сканирование мусора значительно медленнее, в то время как инкрементальный сбор может сканировать только так называемые молодые объекты.

GC.enable(on::Bool)

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

GC.@preserve x1 x2 ... xn expr

Помечает объекты x1, x2, ... как используемые во время вычисления выражения expr. Это необходимо только в небезопасном коде, где expr неявным образом использует память или другие ресурсы, принадлежащие одному из x.

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

• Прямой доступ к памяти объекта через Ptr
• Передача указателя на x в ccall
• Использование ресурсов x, которые будут удалены в финализаторе.

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

Примеры

При загрузке из указателя с помощью unsafe_load, базовый объект используется неявно, например, x неявно используется unsafe_load(p) в следующем:

julia> let
           x = Ref{Int}(101)
           p = Base.unsafe_convert(Ptr{Int}, x)
           GC.@preserve x unsafe_load(p)
       end
101

При передаче указателей на ccall, указываемый объект используется неявно и должен быть сохранён. (Однако, как правило, вы должны просто передать x напрямую в ccall, что считается явным использованием.)

julia> let
           x = "Hello"
           p = pointer(x)
           Int(GC.@preserve x @ccall strlen(p::Cstring)::Csize_t)
           # Preferred alternative
           Int(@ccall strlen(x::Cstring)::Csize_t)
       end
5

GC.safepoint()

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

GC.enable_logging(on::Bool)

При включении печатает статистику о каждом запуске сбора мусора в stderr.

lower(m, x)

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

@lower [m] x

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

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

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

julia> Meta.parse("(α, β) = 3, 5", 1) # start of string
(:((α, β) = (3, 5)), 16)

julia> Meta.parse("(α, β) = 3, 5", 1, greedy=false)
(:((α, β)), 9)

julia> Meta.parse("(α, β) = 3, 5", 16) # end of string
(nothing, 16)

julia> Meta.parse("(α, β) = 3, 5", 11) # index of 3
(:((3, 5)), 16)

julia> Meta.parse("(α, β) = 3, 5", 11, greedy=false)
(3, 13)

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.\"")))

ParseError(msg)

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

QuoteNode

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

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)

@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 выражение расширяется в модуле, заданном в качестве первого аргумента.

@macroexpand1

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

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

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

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

Ключевое слово debuginfo управляет количеством метаданных кода, присутствующих в выводе.

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

code_typed(f, types; kw...)

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

Ключевые аргументы

• optimize=true: управляет тем, применяются ли дополнительные оптимизации, такие как вставка.
• debuginfo=:default: управляет количеством метаданных кода, присутствующих в выводе,

Возможные варианты — :source или :none.

Внутренние ключевые аргументы

Этот раздел следует рассматривать как внутренний и он предназначен только для тех, кто понимает внутренности компилятора Julia.

• world=Base.get_world_counter(): необязательный, управляет возрастом мира, используемого при поиске методов,

использует текущий возраст мира, если не указано иное.

• interp=Core.Compiler.NativeInterpreter(world): необязательный, управляет интерпретатором, используемым,

использует родной интерпретатор Julia, если не указано иное.

Пример

Можно поместить типы аргументов в кортеж, чтобы получить соответствующие code_typed.

julia> code_typed(+, (Float64, Float64))
1-element Vector{Any}:
 CodeInfo(
1 ─ %1 = Base.add_float(x, y)::Float64
└──      return %1
) => Float64

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

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

Base.jit_total_bytes()

Возвращает общее количество (в байтах) выделенной памяти компилятором just-in-time (например, для кода и данных нативных функций).

Meta.quot(ex)::Expr

Цитата выражения ex для создания выражения с заголовком quote. Это может быть использовано, например, для представления объектов типа Expr в АСТ. Смотрите также раздел руководства о QuoteNode.

Примеры

julia> eval(Meta.quot(:x))
:x

julia> dump(Meta.quot(:x))
Expr
  head: Symbol quote
  args: Array{Any}((1,))
    1: Symbol x

julia> eval(Meta.quot(:(1+2)))
:(1 + 2)

Meta.isexpr(ex, head[, n])::Bool

Возвращает true, если ex является Expr с заданным типом head и, необязательно, что список аргументов имеет длину n. head может быть Symbol или коллекцией Symbol. Например, чтобы проверить, что макрос получил выражение вызова функции, вы можете использовать isexpr(ex, :call).

Примеры

julia> ex = :(f(x))
:(f(x))

julia> Meta.isexpr(ex, :block)
false

julia> Meta.isexpr(ex, :call)
true

julia> Meta.isexpr(ex, [:block, :call]) # multiple possible heads
true

julia> Meta.isexpr(ex, :call, 1)
false

julia> Meta.isexpr(ex, :call, 2)
true

 isidentifier(s) -> Bool

Возвращает true, если символ или строка s содержат символы, которые интерпретируются как допустимый обычный идентификатор (не бинарный/унарный оператор) в коде Julia; см. также Base.isoperator.

Внутри Julia разрешается любая последовательность символов в Symbol (кроме \0), и макросы автоматически используют имена переменных, содержащие # для предотвращения конфликтов имён с окружающим кодом. Для того, чтобы анализатор распознал переменную, он использует ограниченный набор символов (значительно расширенный за счёт Юникода). isidentifier() позволяет непосредственно запросить анализатор, содержит ли символ допустимые символы.

Примеры

julia> Meta.isidentifier(:x), Meta.isidentifier("1x")
(true, false)

isoperator(s::Symbol)

Возвращает true, если символ может использоваться как оператор, false — в противном случае.

Примеры

julia> Meta.isoperator(:+), Meta.isoperator(:f)
(true, false)

isunaryoperator(s::Symbol)

Возвращает true, если символ может использоваться как унарный (префиксный) оператор, false — в противном случае.

Примеры

julia> Meta.isunaryoperator(:-), Meta.isunaryoperator(:√), Meta.isunaryoperator(:f)
(true, true, false)

isbinaryoperator(s::Symbol)

Возвращает true, если символ может использоваться как бинарный (инфиксный) оператор, false — в противном случае.

Примеры

julia> Meta.isbinaryoperator(:-), Meta.isbinaryoperator(:√), Meta.isbinaryoperator(:f)
(true, false, false)

Meta.show_sexpr([io::IO,], ex)

Показать выражение ex в стиле S-выражения Lisp.

Примеры

julia> Meta.show_sexpr(:(f(x, g(y,z))))
(:call, :f, :x, (:call, :g, :y, :z))