Essentials

exit(code=0)

プログラムを終了コードで停止します。デフォルトの終了コードはゼロで、プログラムが正常に完了したことを示します。インタラクティブセッションでは、キーボードショートカット ^D を使って exit() を呼び出すことができます。

atexit(f)

プロセス終了時に呼び出されるゼロまたは一引数の関数 f() を登録します。atexit() フックは、後入れ先出し (LIFO) の順序で呼び出され、オブジェクトのファイナライザの前に実行されます。

f に整数引数が1つ定義されているメソッドがある場合、f(n::Int32) として呼び出されます。ここで n は現在の終了コードです。それ以外の場合は、f() として呼び出されます。

終了フックは exit(n) を呼び出すことが許可されており、その場合、Julia は終了コード n で終了します（元の終了コードではなく）。複数の終了フックが exit(n) を呼び出す場合、Julia は exit(n) を呼び出す最後の終了フックに対応する終了コードで終了します。（終了フックは LIFO 順序で呼び出されるため、「最後に呼び出された」は「最初に登録された」と同等です。）

注意: すべての終了フックが呼び出された後は、これ以上の終了フックを登録することはできず、すべてのフックが完了した後に atexit(f) を呼び出すと例外がスローされます。この状況は、シャットダウン中にまだ同時に実行されている可能性のあるバックグラウンドタスクから終了フックを登録している場合に発生する可能性があります。

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

__precompile__(isprecompilable::Bool)

この関数を呼び出すファイルがプリコンパイル可能かどうかを指定します。デフォルトは true です。モジュールまたはファイルが安全にプリコンパイルできない場合は、Juliaがそれをプリコンパイルしようとしたときにエラーをスローするために __precompile__(false) を呼び出す必要があります。

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

モジュール m のグローバルスコープで入力ソースファイルの内容を評価します。 baremodule で定義されたモジュールを除いて、すべてのモジュールは m 引数を省略した独自の include 定義を持ち、そのモジュール内でファイルを評価します。入力ファイルの最後に評価された式の結果を返します。インクルード中は、タスクローカルのインクルードパスがファイルを含むディレクトリに設定されます。ネストされた include 呼び出しは、そのパスに対して相対的に検索されます。この関数は通常、インタラクティブにソースをロードするため、または複数のソースファイルに分割されたパッケージ内のファイルを結合するために使用されます。

オプションの最初の引数 mapexpr は、評価される前にインクルードされたコードを変換するために使用できます：path 内の各解析された式 expr に対して、include 関数は実際に mapexpr(expr) を評価します。省略された場合、mapexpr は identity にデフォルト設定されます。

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

入力ソースファイルの内容を、含まれているモジュールのグローバルスコープで評価します。baremoduleで定義されたモジュールを除いて、すべてのモジュールには独自のincludeの定義があり、そのモジュール内でファイルを評価します。入力ファイルの最後に評価された式の結果を返します。インクルード中は、タスクローカルのインクルードパスがファイルを含むディレクトリに設定されます。ネストされたincludeの呼び出しは、そのパスに対して相対的に検索されます。この関数は通常、インタラクティブにソースをロードするため、または複数のソースファイルに分割されたパッケージ内のファイルを結合するために使用されます。引数pathはnormpathを使用して正規化され、..のような相対パスのトークンを解決し、/を適切なパスセパレーターに変換します。

オプションの最初の引数mapexprは、評価される前に含まれるコードを変換するために使用できます：path内の各解析された式exprに対して、include関数は実際にmapexpr(expr)を評価します。省略した場合、mapexprはidentityにデフォルト設定されます。

別のモジュールにファイルを評価するには、Base.includeを使用してください。

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

includeと同様ですが、ファイルからではなく、指定された文字列からコードを読み込みます。

オプションの最初の引数mapexprは、評価される前に含まれるコードを変換するために使用できます：code内の各解析された式exprに対して、include_string関数は実際にmapexpr(expr)を評価します。省略した場合、mapexprはidentityにデフォルト設定されます。

include_dependency(path::AbstractString; track_content::Bool=true)

モジュール内で、path（相対または絶対）の指定されたファイル、ディレクトリ、またはシンボリックリンクがプリコンパイルの依存関係であることを宣言します。つまり、track_content=trueの場合、pathの内容が変更されるとモジュールは再コンパイルが必要になります（pathがディレクトリの場合、内容はjoin(readdir(path))に等しいです）。track_content=falseの場合、pathの修正時間mtimeが変更されると再コンパイルがトリガーされます。

これは、モジュールがincludeを介して使用されていないパスに依存している場合にのみ必要です。コンパイルの外では効果がありません。

__init__

__init__() 関数は、モジュールがランタイムで初めて読み込まれた 後 に即座に実行されます。これは、モジュール内の他のすべてのステートメントが実行された後に一度だけ呼び出されます。モジュールを完全にインポートした後に呼び出されるため、サブモジュールの __init__ 関数が最初に実行されます。__init__ の典型的な使用例は、外部 C ライブラリのランタイム初期化関数を呼び出すことと、外部ライブラリによって返されるポインタを含むグローバル定数を初期化することです。詳細については、モジュールに関するマニュアルセクションを参照してください。

例

const foo_data_ptr = Ref{Ptr{Cvoid}}(0)
function __init__()
    ccall((:foo_init, :libfoo), Cvoid, ())
    foo_data_ptr[] = ccall((:foo_data, :libfoo), Ptr{Cvoid}, ())
    nothing
end

which(f, types)

指定された types の引数に対して呼び出される f のメソッド（Method オブジェクト）を返します。

types が抽象型である場合、invoke によって呼び出されるメソッドが返されます。

関連情報: parentmodule, @which, および @edit.

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

fのメソッドテーブルを返します。

typesが指定されている場合、型が一致するメソッドの配列を返します。moduleが指定されている場合、そのモジュールで定義されたメソッドの配列を返します。モジュールのリストも配列として指定できます。

参照: which, @which および methodswith.

@show exs...

1つ以上の式とその結果を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

最後に計算された値を参照する変数で、インタラクティブプロンプトに自動的にインポートされます。

err

最後にスローされたエラーを参照する変数で、インタラクティブプロンプトに自動的にインポートされます。スローされたエラーは例外のスタックに収集されます。

active_project()

アクティブな Project.toml ファイルのパスを返します。詳細は Base.set_active_project を参照してください。

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

アクティブな Project.toml ファイルを projfile に設定します。詳細は Base.active_project を参照してください。

module

moduleはModuleを宣言し、これは別のグローバル変数のワークスペースです。モジュール内では、他のモジュールからどの名前が見えるかを制御（インポートを通じて）し、自分の名前のうちどれが公開されるべきかを指定できます（exportおよびpublicを通じて）。モジュールを使用することで、他の誰かのコードと一緒に使用される際の名前の衝突を心配することなく、トップレベルの定義を作成できます。詳細については、モジュールに関するマニュアルのセクションを参照してください。

例

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したときに利用可能にします。詳細については、モジュールに関するマニュアルセクションを参照してください。

public

public はモジュール内で使用され、Julia に対してそのモジュールのパブリック API の一部である名前を示します。例えば、public foo は名前 foo がパブリックであることを示しますが、モジュールを using したときに利用可能にするわけではありません。詳細については、モジュールに関するマニュアルセクション を参照してください。

import

import Foo はモジュールまたはパッケージ Foo をロードします。インポートされた Foo モジュールからの名前は、ドット構文を使用してアクセスできます（例：Foo.foo で名前 foo にアクセス）。詳細については、モジュールに関するマニュアルセクションを参照してください。

using

using Foo はモジュールまたはパッケージ Foo をロードし、その export された名前を直接使用できるようにします。名前はドット構文（例: Foo.foo で名前 foo にアクセス）を介しても使用できます。これは export されているかどうかに関係ありません。詳細については、モジュールに関するマニュアルセクションを参照してください。

as

as は、import または using によってスコープに持ち込まれた識別子の名前を変更するためのキーワードとして使用され、名前の衝突を回避する目的や名前を短縮するために使われます。 (import または using ステートメントの外では、as はキーワードではなく、通常の識別子として使用できます。)

import LinearAlgebra as LA は、インポートされた LinearAlgebra 標準ライブラリを LA としてスコープに持ち込みます。

import LinearAlgebra: eigen as eig, cholesky as chol は、LinearAlgebra から eigen および cholesky メソッドをそれぞれ eig と chol としてスコープに持ち込みます。

as は、個々の識別子がスコープに持ち込まれる場合にのみ using と一緒に機能します。たとえば、using LinearAlgebra: eigen as eig または using LinearAlgebra: eigen as eig, cholesky as chol は機能しますが、using LinearAlgebra as LA は無効な構文です。なぜなら、LinearAlgebra からエクスポートされた すべての 名前を LA に変更することは意味がないからです。

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 は、生成されたコードをプログラムに挿入するためのメソッドを定義します。マクロは、引数の式のシーケンスを返される式にマッピングし、結果の式はマクロが呼び出されたポイントでプログラムに直接置き換えられます。マクロは、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 を返します。

2番目の例も同じように動作すると思うかもしれませんが、実際にはそこでの 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 は、コレクションの最初のインデックスや配列の次元の最初のインデックスを表すためにインデックス指定時にも使用できます。例えば、a[begin] は配列 a の最初の要素です。

例

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 ブロックにローカルであり、代入は順番に評価され、各右辺は左辺の名前を考慮せずにスコープ内で評価されます。したがって、let x = x のように書くことは理にかなっています。なぜなら、2つの x 変数は異なり、左辺が外部スコープの x をローカルにシャドウイングしているからです。これは、ローカルスコープに入るたびに新しいローカル変数が新たに作成されるため、特にクロージャを介してスコープを超えて生き残る変数の場合に有用なイディオムとなります。上記の例の var2 のように、代入なしの let 変数は、まだ値にバインドされていない新しいローカル変数を宣言します。

対照的に、begin ブロックは複数の式をまとめますが、スコープを導入したり、特別な代入構文を持ったりしません。

例

以下の関数では、単一の x が map によって3回反復的に更新されます。返されるクロージャはすべてその1つの x を最終値で参照します。

julia> function test_outer_x()
           x = 0
           map(1:3) do _
               x += 1
               return ()->x
           end
       end
test_outer_x (generic function with 1 method)

julia> [f() for f in test_outer_x()]
3-element Vector{Int64}:
 3
 3
 3

しかし、新しい ローカル変数を導入する let ブロックを追加すると、同じ名前を使用（シャドウ）することを選んでも、3つの異なる変数がキャプチャされることになります（各反復ごとに1つずつ）。

julia> function test_let_x()
           x = 0
           map(1:3) do _
               x += 1
               let x = x
                   return ()->x
               end
           end
       end
test_let_x (generic function with 1 method)

julia> [f() for f in test_let_x()]
3-element Vector{Int64}:
 1
 2
 3

新しいローカル変数を導入するすべてのスコープ構造は、繰り返し実行されるとこのように動作します。let の特徴的な機能は、同じ名前の外部変数をシャドウイングする新しい local を簡潔に宣言できることです。たとえば、do 関数の引数を直接使用することも、同様に3つの異なる変数をキャプチャします。

julia> function test_do_x()
           map(1:3) do x
               return ()->x
           end
       end
test_do_x (generic function with 1 method)

julia> [f() for f in test_do_x()]
3-element Vector{Int64}:
 1
 2
 3

if/elseif/else

if/elseif/else は条件評価を行い、ブール式の値に応じてコードの一部を評価するかどうかを決定します。以下は if/elseif/else 条件構文の構造です：

if x < y
    println("x は y より小さい")
elseif x > y
    println("x は y より大きい")
else
    println("x は 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 ループは、値のシーケンスを反復処理しながら、ステートメントのブロックを繰り返し評価します。

反復変数は常に新しい変数であり、たとえ同じ名前の変数が外側のスコープに存在していてもそうです。反復のために既存のローカル変数を再利用するには、outer を使用してください。

例

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

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 "ファイルを書き込めませんでした。"
end

または、ファイルを変数に読み込めない場合：

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "ファイルが見つかりません。"
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 # ループローカルの 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 # fooの外で定義されたz変数を使用
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6

for outer

for ループで反復のために既存のローカル変数を再利用します。

詳細については、変数のスコープに関するマニュアルセクションを参照してください。

また、forも参照してください。

例

julia> function f()
           i = 0
           for i = 1:3
               # 空
           end
           return i
       end;

julia> f()
0

julia> function f()
           i = 0
           for outer i = 1:3
               # 空
           end
           return i
       end;

julia> f()
3

julia> i = 0 # グローバル変数
       for outer i = 1:3
       end
ERROR: 構文エラー: "for outer" に対する外部ローカル変数宣言が存在しません
[...]

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は<:構文を使用して抽象スーパタイプを宣言することもできます：

struct Point <: AbstractPoint
    x
    y
end

structはデフォルトで不変です。これらの型のインスタンスは構築後に変更することはできません。インスタンスを変更可能な型を宣言するには、代わりにmutable structを使用してください。

コンストラクタの定義方法など、詳細についてはComposite Typesのマニュアルセクションを参照してください。

mutable struct

mutable structはstructに似ていますが、構築後に型のフィールドを設定することも可能です。

ミュータブル構造体の個々のフィールドは、constとしてマークすることで不変にすることができます：

mutable struct Baz
    a::Int
    const b::Float64
end

詳細については、Composite Typesのマニュアルセクションを参照してください。

@kwdef typedef

これは、typedefという式で宣言された型（structまたはmutable struct式である必要があります）に対して、キーワードベースのコンストラクタを自動的に定義するヘルパーマクロです。デフォルト引数は、field::T = defaultまたはfield = defaultの形式でフィールドを宣言することによって提供されます。デフォルトが提供されない場合、キーワード引数は結果の型コンストラクタにおいて必須のキーワード引数となります。

内部コンストラクタはまだ定義できますが、少なくとも1つはデフォルトの内部コンストラクタと同じ形式（すなわち、各フィールドに対して1つの位置引数）で引数を受け入れる必要があります。そうしないと、キーワード外部コンストラクタと正しく機能しません。

例

julia> @kwdef struct Foo
           a::Int = 1         # 指定されたデフォルト
           b::String          # 必須のキーワード
       end
Foo

julia> Foo(b="hi")
Foo(1, "hi")

julia> Foo()
ERROR: UndefKeywordError: keyword argument `b` not assigned
Stacktrace:
[...]

抽象型

抽象型はインスタンス化できない型を宣言し、型グラフのノードとしてのみ機能し、関連する具体的な型の集合を記述します：それらの具体的な型はその子孫です。抽象型は、Juliaの型システムを単なるオブジェクト実装のコレクション以上のものにする概念的な階層を形成します。例えば：

abstract type Number end
abstract type Real <: Number end

Numberにはスーパタイプがなく、RealはNumberの抽象サブタイプです。

プリミティブ型

プリミティブ型は、データがビットの系列のみから構成される具体的な型を宣言します。プリミティブ型の古典的な例には、整数や浮動小数点値があります。いくつかの組み込みプリミティブ型宣言の例：

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

名前の後の数は、その型が必要とするストレージのビット数を示します。現在、サポートされているのは8ビットの倍数のサイズのみです。Boolの宣言は、プリミティブ型が任意にあるスーパタイプのサブタイプとして宣言できる方法を示しています。

where

where キーワードは UnionAll 型を作成します。これは、ある変数のすべての値に対して他の型の反復的な和として考えることができます。例えば、Vector{T} where T<:Real は、要素型が何らかの Real 数であるすべての Vector を含みます。

変数の境界は省略された場合、デフォルトで Any になります：

Vector{T} where T    # `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

;

; は多くのC系言語と同様にJuliaでも同じ役割を持ち、前の文の終わりを区切るために使用されます。

; は行の終わりに必要ではありませんが、単一の行で文を区切ったり、文を単一の式に結合したりするために使用できます。

REPLの行の終わりに ; を追加すると、その式の結果の印刷を抑制します。

関数の宣言では、オプションで呼び出しの中で、； は通常の引数とキーワードを区切ります。

配列リテラルでは、セミコロンで区切られた引数の内容が結合されます。単一の ; で作られた区切りは垂直に結合します（すなわち、最初の次元に沿って）、;; は水平方向に結合します（第二次元）、;;; は第三次元に沿って結合します。こうした区切りは、長さ1のトレーリング次元を追加するために、角括弧の最後の位置でも使用できます。

括弧内の最初の位置にある ; は、名前付きタプルを構築するために使用できます。同じ (; ...) 構文を代入の左側で使用すると、プロパティの分解が可能です。

標準の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> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

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

[:, :, 2] =
 10  20
 30  40

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

julia> nt = (; x=1) # ; やトレーリングカンマがなければ、これは x に代入されます
(x = 1,)

julia> key = :a; c = 3;

julia> nt2 = (; key => 1, b=2, c, nt.x)
(a = 1, b = 2, c = 3, x = 1)

julia> (; b, x) = nt2; # プロパティの分解を使用して変数 b と x を設定

julia> b, x
(2, 1)

julia> ; # ; を入力すると、プロンプトが（その場で）次のように変更されます: 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("x is not larger")
x is not larger

julia> x > y ? "x is larger" : x == y ? "x and y are equal" : "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モジュールは、Juliaオブジェクトのドキュメンテーションメタデータを設定および取得するために使用できる@docマクロを提供します。

詳細については、ドキュメンテーションに関するマニュアルセクションを参照してください。

イテレータを扱うためのメソッド。

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

==と似ていますが、浮動小数点数と欠損値の扱いが異なります。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)のうちの正確に1つがtrueでなければならず（他の2つは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)も定義されており、これらの3つのうちの正確に1つがtrueを返します。
• islessによって定義される関係は推移的です。すなわち、isless(x, y) && isless(y, z)が成り立つ場合、isless(x, z)も成り立ちます。

通常順序付けされない値、例えばNaNは、通常の値の後に順序付けされます。missing値は最後に順序付けされます。

これはsort!によって使用されるデフォルトの比較です。

実装

全順序を持つ非数値型は、この関数を実装する必要があります。数値型は、NaNのような特別な値を持つ場合にのみ実装する必要があります。部分順序を持つ型は<を実装する必要があります。ソートや関連する関数で使用できる代替順序メソッドを定義する方法については、Alternate Orderingsのドキュメントを参照してください。

例

julia> isless(1, 3)
true

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

isunordered(x)

xが<に従って順序付けできない値（例えばNaNやmissing）である場合、trueを返します。

この述語でtrueと評価される値は、islessなどの他の順序付けに関しては順序付け可能である場合があります。

ifelse(condition::Bool, x, y)

conditionがtrueの場合はxを返し、そうでなければyを返します。これは?やifとは異なり、通常の関数であるため、すべての引数が最初に評価されます。場合によっては、if文の代わりにifelseを使用することで、生成されたコードの分岐を排除し、タイトなループでのパフォーマンスを向上させることができます。

例

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

typeassert(x, type)

x isa type でない場合は TypeError をスローします。構文 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, ntuple, NamedTuple。

例

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

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

julia> Tuple(Real[1, 2, pi])  # コレクションを受け取ります
(1, 2, π)

ntuple(f, 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 は整数として長さを取るバージョンよりも効率的なコードを生成する可能性があります。しかし、N がコンパイル時に決定できない場合は、ntuple(f, N) が ntuple(f, Val(N)) よりも好まれます。

例

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

objectid(x) -> UInt

オブジェクトのアイデンティティに基づいて x のハッシュ値を取得します。

もし x === y であれば objectid(x) == objectid(y) となり、通常 x !== y の場合は objectid(x) != objectid(y) となります。

関連情報として hash、IdDict を参照してください。

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

整数ハッシュコードを計算します。isequal(x,y) が成り立つ場合、hash(x)==hash(y) も成り立ちます。オプションの第二引数 h は、結果と混合される別のハッシュコードです。

新しい型は、通常、内容のハッシュを互いに（および h と）混合するために、2引数の hash メソッドを再帰的に呼び出すことによって、2引数形式を実装する必要があります。通常、hash を実装する任意の型は、上記の性質を保証するために独自の ==（したがって isequal）も実装する必要があります。

ハッシュ値は、新しいJuliaプロセスが開始されると変更される可能性があります。

julia> a = hash(10)
0x95ea2955abd45275

julia> hash(10, a) # 別のハッシュ関数の出力を第二引数としてのみ使用
0xd42bad54a8575b16

参照: objectid, Dict, Set.

finalizer(f, x)

関数 f(x) を登録し、x へのプログラムからアクセス可能な参照がなくなったときに呼び出され、x を返します。x の型は mutable struct でなければならず、そうでない場合は関数がエラーをスローします。

f はタスクスイッチを引き起こしてはいけません。これにより、println のようなほとんどの I/O 操作が除外されます。デバッグ目的で、@async マクロを使用して（ファイナライザの外でコンテキストスイッチを遅延させるため）たり、C の I/O 関数を直接呼び出すために ccall を使用することが役立つ場合があります。

f の実行に対して保証されたワールドエイジはありません。ファイナライザが登録されたワールドエイジまたはそれ以降のワールドエイジで呼び出される可能性があります。

例

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 を参照してください。

deepcopy(x)

xのディープコピーを作成します：すべてが再帰的にコピーされ、完全に独立したオブジェクトが生成されます。たとえば、配列をディープコピーすると、その配列が含むすべてのオブジェクトのディープコピーが作成され、一貫した関係構造を持つ新しい配列が生成されます（たとえば、元の配列の最初の2つの要素が同じオブジェクトである場合、新しい配列の最初の2つの要素も同じdeepcopyされたオブジェクトになります）。オブジェクトに対してdeepcopyを呼び出すことは、一般的にシリアライズしてからデシリアライズするのと同じ効果があります。

通常は必要ありませんが、ユーザー定義型は、deepcopy_internal(x::T, dict::IdDict)という関数の特別なバージョンを定義することで、デフォルトのdeepcopyの動作をオーバーライドできます（これは他の目的では使用しないべきです）。ここで、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{T <: Number}
           x::T
       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

getproperty は必要な場合にのみオーバーロードすべきです。なぜなら、構文 obj.f の動作が異常であると混乱を招く可能性があるからです。また、メソッドを使用することがしばしば好ましいことにも注意してください。詳細については、このスタイルガイドのドキュメントを参照してください: Prefer exported methods over direct field access。

また、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 は setproperty!(a, :b, c, :sequentially_consistent) を呼び出します。

関連情報として setfield!, propertynames および getproperty を参照してください。

replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

x.fのexpectedからdesiredへの比較とスワップ操作を行います。関数呼び出し形式の代わりに、構文@atomicreplace x.f expected => desiredを使用できます。

また、replacefield!、setproperty!、setpropertyonce!も参照してください。

swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)

構文 @atomic a.b, _ = c, a.b は (c, swapproperty!(a, :b, c, :sequentially_consistent)) を返します。このとき、両側に共通する getproperty 式が1つ必要です。

また、swapfield! と setproperty! も参照してください。

modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)

構文 @atomic op(x.f, v)（およびその同等の @atomic x.f op v）は modifyproperty!(x, :f, op, v, :sequentially_consistent) を返します。ここで、最初の引数は getproperty 式でなければならず、原子的に修正されます。

op(getproperty(x, f), v) の呼び出しは、デフォルトでオブジェクト x のフィールド f に格納できる値を返さなければなりません。特に、setproperty! のデフォルトの動作とは異なり、convert 関数は自動的には呼び出されません。

他に modifyfield! と setproperty! も参照してください。

setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

x.fに対して比較と入れ替えの操作を行い、以前に設定されていなければvalueに設定します。関数呼び出し形式の代わりに@atomiconce x.f = valueという構文を使用できます。

関連情報としては、setfieldonce!, setproperty!, replaceproperty!があります。

propertynames(x, private=false)

オブジェクト x のプロパティ（x.property）のタプルまたはベクターを取得します。これは通常 fieldnames(typeof(x)) と同じですが、getproperty をオーバーロードするタイプは、タイプのインスタンスのプロパティを取得するために propertynames もオーバーロードする必要があります。

propertynames(x) は、x の文書化されたインターフェースの一部である「公開」プロパティ名のみを返す場合があります。内部使用を目的とした「プライベート」プロパティ名も返すようにしたい場合は、オプションの第二引数に true を渡してください。x. に対する REPL のタブ補完は、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])

valueの名前付きフィールドにxを割り当てます。valueは可変でなければならず、xはfieldtype(typeof(value), name)のサブタイプでなければなりません。さらに、この操作のために順序を指定することができます。フィールドが@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

modifyfield!(value, name::Symbol, op, x, [order::Symbol]) -> Pair
modifyfield!(value, i::Int, op, x, [order::Symbol]) -> Pair

関数 op を適用した後にフィールドを取得して設定する操作を原子的に実行します。

y = getfield(value, name)
z = op(y, x)
setfield!(value, name, z)
return y => z

ハードウェアがサポートしている場合（例えば、原子的なインクリメント）、これは適切なハードウェア命令に最適化される可能性があります。そうでない場合は、ループを使用します。

replacefield!(value, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
replacefield!(value, i::Int, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

原子操作を実行して、フィールドを指定された値に条件付きで設定します。

y = getfield(value, name, fail_order)
ok = y === expected
if ok
    setfield!(value, name, desired, success_order)
end
return (; old = y, success = ok)

ハードウェアがサポートしている場合、これは適切なハードウェア命令に最適化される可能性があります。そうでない場合は、ループを使用します。

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

フィールドを同時に取得して設定する操作を原子的に実行します：

y = getfield(value, name)
setfield!(value, name, x)
return y

setfieldonce!(value, name::Union{Int,Symbol}, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

与えられた値にフィールドを設定する操作を原子的に実行します。ただし、以前に設定されていなかった場合のみ実行します。

ok = !isdefined(value, name, fail_order)
if ok
    setfield!(value, name, desired, success_order)
end
return ok

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型の場合、xがTで表現できない場合（例えば、xが整数値でない場合や、Tがサポートする範囲外の場合）には、InexactErrorが発生します。

例

julia> convert(Int, 3.0)
3

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

TがAbstractFloat型の場合、Tで表現可能なxに最も近い値が返されます。Infは、最も近い値を決定する目的でfloatmax(T)よりも1 ulp大きいものとして扱われます。

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)

julia> promote_type(Int8, Float16, Float32)
Float32

julia> reduce(Base.promote_typejoin, (Int8, Float16, Float32))
Real

julia> promote(1, "x")
ERROR: promotion of types Int64 and String failed to change any arguments
[...]

julia> promote_type(Int, String)
Any

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 はビット数が2倍の型を返します。

x が値である場合、widen(typeof(x)) に変換されます。

例

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

恒等関数。引数を返します。

参照: one, oneunit, および LinearAlgebra の I。

例

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

WeakRef(x)

w = WeakRef(x) は、Juliaの値 x への 弱参照 を構築します： w は x への参照を含んでいますが、x がガーベジコレクトされるのを防ぎません。 w.value は、x がまだガーベジコレクトされていない場合は x であり、x がガーベジコレクトされている場合は nothing です。

julia> x = "a string"
"a string"

julia> w = WeakRef(x)
WeakRef("a string")

julia> GC.gc()

julia> w           # `x` を介して参照が維持されます
WeakRef("a string")

julia> x = nothing # 参照をクリア

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::DataType)

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)

サブタイプ演算子: 型 T1 のすべての値が型 T2 の値でもある場合に限り true を返します。

例

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

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

>:(T1, T2)

スーパタイプ演算子で、T2 <: T1 と同等です。

typejoin(T, S, ...)

型 T と S の最も近い共通の祖先を返します。つまり、両方が継承する最も狭い型です。追加の varargs に対して再帰します。

例

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number

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

T と S の交差を含む型を計算します。通常、これは最小のそのような型、またはそれに近いものになります。

正確な動作が保証される特別なケース: T <: S の場合、typeintersect(S, T) == T == typeintersect(T, S) です。

promote_type(type1, type2, ...)

プロモーションは、混合型の値を単一の共通型に変換することを指します。promote_typeは、異なる型の引数が与えられたときのJuliaにおけるデフォルトのプロモーション動作を表します。promote_typeは、一般的に、過度に広がることなく、少なくともどちらの入力型のほとんどの値を近似できる型を返そうとします。いくつかの損失は許容されます。たとえば、promote_type(Int64, Float64)は、厳密にはすべてのInt64値が正確にFloat64値として表現できるわけではありませんが、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)

type1 と type2 の型の値が与えられたときに promote が使用すべき型を指定します。この関数は直接呼び出すべきではなく、新しい型に対して適切に定義を追加する必要があります。

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 がタプルの「リーフ型」であるかどうかを判断します。これは、ディスパッチの型シグネチャに現れる可能性があり、呼び出しに現れる可能性のあるサブタイプ（またはスーパタイプ）を持たないことを意味します。もし T が型でない場合は、false を返します。

ismutable(v) -> Bool

値 v がミュータブルである場合にのみ true を返します。イミュータビリティについての議論は Mutable Composite Types を参照してください。この関数は値に対して動作するため、DataType を与えると、その型の値がミュータブルであると教えてくれます。

他にも isbits、isstructtype を参照してください。

例

julia> ismutable(1)
false

julia> ismutable([1,2])
true

isimmutable(v) -> Bool

値 v が不変である場合にのみ true を返します。 不変性についての議論は Mutable Composite Types を参照してください。この関数は値に対して動作するため、型を与えると DataType の値が可変であると返します。

例

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

ismutabletype(T) -> Bool

型 T が可変型として宣言されたかどうかを判断します（つまり、mutable struct キーワードを使用して）。もし T が型でない場合は、false を返します。

isabstracttype(T)

型 T が抽象型として宣言されたかどうかを判断します（つまり、abstract type 構文を使用して）。これは isconcretetype(T) の否定ではないことに注意してください。もし T が型でない場合は、false を返します。

例

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

型 T がプリミティブ型として宣言されたかどうかを判断します（つまり、primitive type 構文を使用して）。もし T が型でない場合は、false を返します。

Base.issingletontype(T)

型 T が正確に1つのインスタンスを持つかどうかを判断します。たとえば、他のシングルトン値を除いてフィールドを持たない構造体型です。T が具体的な型でない場合は、false を返します。

isstructtype(T) -> Bool

型 T が構造体型として宣言されたかどうかを判断します（つまり、struct または mutable struct キーワードを使用して）。もし T が型でない場合は、false を返します。

nameof(t::DataType) -> Symbol

DataType（親モジュールなし）の名前をシンボルとして取得します（UnionAllでラップされている可能性があります）。

例

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)

DataTypeのフィールドiの名前を取得します。

例

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が自身のフィールドの1つとして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 で、2つのフィールドを持っています。 b は Int で、フィールドがまったくない原始的なビット型です。 ex は ErrorException で、1つのフィールドを持っています。

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

指定されたモジュール m でグローバルが const として宣言されているかどうかを判断します。

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

与えられた型 t において、フィールド s が const として宣言されているかどうかを判断します。

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

与えられた型 t において、フィールド s が @atomic として宣言されているかどうかを判断します。

sizeof(T::DataType)
sizeof(obj)

与えられた DataType T の標準的なバイナリ表現のサイズ（バイト単位）。または、DataType でない場合はオブジェクト obj のサイズ（バイト単位）。

詳細は Base.summarysize を参照してください。

例

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

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

julia> struct StructWithPadding
           x::Int64
           flag::Bool
       end

julia> sizeof(StructWithPadding) # パディングのためフィールドの `sizeof` の合計ではない
16

julia> sizeof(Int64) + sizeof(Bool) # 上記とは異なる
9

DataType T に特定のサイズがない場合、エラーが発生します。

julia> sizeof(AbstractArray)
ERROR: 抽象型 AbstractArray には明確なサイズがありません。
Stacktrace:
[...]

isconcretetype(T)

型 T が具体的な型であるかどうかを判断します。具体的な型とは、直接的なインスタンス（typeof(x) === T となる値 x）を持つ可能性がある型を意味します。これは isabstracttype(T) の否定ではないことに注意してください。T が型でない場合は、false を返します。

関連情報: 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)

x が isbitstype 型のインスタンスであれば true を返します。

isbitstype(T)

型 T が「プレーンデータ」型である場合は true を返します。これは、型 T が不変であり、他の値への参照を含まず、primitive 型および他の isbitstype 型のみを含むことを意味します。典型的な例としては、UInt8、Float64、および Complex{Float64} のような数値型があります。このカテゴリの型は重要であり、型パラメータとして有効であり、isdefined / isassigned ステータスを追跡しない可能性があり、C と互換性のある定義されたレイアウトを持っています。もし T が型でない場合は、false を返します。

他にも 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の任意の型に対して呼び出すことができますが、Memoryの場合は全体のオブジェクトではなく、要素のアライメントを返します。

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

この型のインスタンスのフィールドがメモリ内でパッキングされているかどうかを返します。すなわち、構造体のフィールドに適用されたときに等価テストに唯一影響を与えないビット（パディングビットと定義される）が介在しないことを意味します。isconcretetypeに対して呼び出すことができます。

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

この型のインスタンスがガベージコレクション管理メモリへの参照を含むことができるかどうかを返します。isconcretetypeの任意のものに対して呼び出すことができます。

typemin(T)

与えられた（実数の）数値データ型 T によって表現可能な最小値。

参照: floatmin, typemax, eps。

例

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # 最小の有限 Float32 浮動小数点数
-3.4028235f38

typemax(T)

指定された（実数の）数値 DataType によって表現可能な最大値。

参照: floatmax, typemin, eps。

例

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # 最大の有限な Float32 浮動小数点数
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+1 が型 T で正確に表現できない最小の正の整数値の浮動小数点数 n を返します。

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)

xの最小単位（ulp）を返します。これは、xにおける連続する表現可能な浮動小数点値の間の距離です。ほとんどの場合、xの両側の距離が異なる場合は、2つのうち大きい方が取られます。つまり、

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

このルールの例外は、最小および最大の有限値（例えば、Float64のnextfloat(-Inf)およびprevfloat(Inf)）であり、これらは値の小さい方に丸められます。

この動作の理由は、epsが浮動小数点の丸め誤差を制限することです。デフォルトのRoundNearest丸めモードの下で、$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)      # 最大の有限Float64
1.7976931348623157e308

julia> x + eps(x)/2            # 切り上げ
Inf

julia> x + prevfloat(eps(x)/2) # 切り下げ
1.7976931348623157e308

instances(T::Type)

指定された型のすべてのインスタンスのコレクションを返します。主に列挙型に使用されます（@enumを参照）。

例

julia> @enum Color red blue green

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

Any::DataType

Anyはすべての型の和集合です。任意のxに対してisa(x, Any) == trueという定義的な性質を持っています。したがって、Anyは可能な値の全宇宙を表します。例えば、IntegerはInt、Int8、および他の整数型を含むAnyの部分集合です。

Union{Types...}

Union型は、その引数型のいずれかのインスタンスをすべて含む抽象型です。これは、T <: Union{T,S} および S <: Union{T,S} を意味します。

他の抽象型と同様に、すべての引数が非抽象であっても、インスタンス化することはできません。

例

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

julia> 1 isa IntOrString # Intのインスタンスはユニオンに含まれています
true

julia> "Hello!" isa IntOrString # Stringも含まれています
true

julia> 1.0 isa IntOrString # Float64はIntでもAbstractStringでもないため含まれていません
false

拡張ヘルプ

ほとんどの他のパラメトリック型とは異なり、ユニオンはそのパラメータに対して共変です。たとえば、Union{Real, String}はUnion{Number, AbstractString}のサブタイプです。

空のユニオン Union{} は、Juliaのボトム型です。

Union{}

Union{}、型の空の Union は、値を持たない型です。つまり、任意の x に対して isa(x, Union{}) == false という定義特性を持っています。Base.Bottom はそのエイリアスとして定義されており、Union{} の型は Core.TypeofBottom です。

例

julia> isa(nothing, Union{})
false

UnionAll

型パラメータのすべての値にわたる型の和。UnionAllは、いくつかのパラメータの値が不明な場合のパラメトリック型を説明するために使用されます。UnionAll Typesに関するマニュアルのセクションを参照してください。

例

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

タプルは、異なる型の任意の値を保持できる固定長のコンテナですが、変更することはできません（不変です）。値はインデックスを介してアクセスできます。タプルリテラルはカンマと括弧で書かれます：

julia> (1, 1+1)
(1, 2)

julia> (1,)
(1,)

julia> x = (0.0, "hello", 6*7)
(0.0, "hello", 42)

julia> x[2]
"hello"

julia> typeof(x)
Tuple{Float64, String, Int64}

長さ1のタプルはカンマを付けて書かなければなりません (1,)、なぜなら (1) は単に括弧で囲まれた値だからです。() は空（長さ0）のタプルを表します。

タプルは、コンストラクタとして Tuple 型を使用することでイテレータから構築できます：

julia> Tuple(["a", 1])
("a", 1)

julia> Tuple{String, Float64}(["a", 1])
("a", 1.0)

タプル型はそのパラメータにおいて共変です：Tuple{Int} は Tuple{Any} のサブタイプです。したがって、Tuple{Any} は抽象型と見なされ、タプル型はそのパラメータが具体的である場合にのみ具体的です。タプルにはフィールド名はなく、フィールドはインデックスによってのみアクセスされます。タプル型は任意の数のパラメータを持つことができます。

タプル型に関するマニュアルのセクションを参照してください。

また、Vararg、NTuple、ntuple、tuple、NamedTupleも参照してください。

NTuple{N, T}

長さ N のタプルの型を表すコンパクトな方法で、すべての要素は型 T です。

例

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

関連項目 ntuple.

NamedTuple

NamedTupleは、その名前が示すように、名前付きTupleです。つまり、各エントリが一意の名前を持つ、タプルのような値のコレクションです。この名前はSymbolとして表されます。Tupleと同様に、NamedTupleは不変であり、構築後に名前や値をその場で変更することはできません。

名前付きタプルは、キーを持つタプルリテラルとして作成できます。例えば、(a=1, b=2)や、開き括弧の後にセミコロンを付けたタプルリテラルとして、例えば(; a=1, b=2)（この形式は、以下に説明するようにプログラムで生成された名前も受け入れます）や、コンストラクタとしてNamedTuple型を使用して、例えばNamedTuple{(:a, :b)}((1,2))のように作成できます。

名前付きタプル内の名前に関連付けられた値にアクセスするには、フィールドアクセス構文を使用します。例えば、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のペアを指定することで作成できます。この形式とname=value構文は混在させることができます：

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

名前と値のペアは、名前付きタプルをスプラットするか、各シンボルを最初の値として持つ2値コレクションを生成するイテレータを使用して提供することもできます：

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

julia> NamedTuple{keys}(values)
(a = 1, b = 2, c = 3)

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

julia> nt1 = (a=1, b=2);

julia> nt2 = (c=3, d=4);

julia> (; nt1..., nt2..., b=20) # 最後のbはnt1からの値を上書きします
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zipは(:a, 1)のようなタプルを生成します
(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 宣言に似ています）が、それ以外は同等です。NamedTuple マクロは、NamedTuple 型を印刷する際に使用されます。たとえば、タプル (a=3.1, b="hello") は型 NamedTuple{(:a, :b), Tuple{Float64, String}} を持ち、これは次のように @NamedTuple を使用して宣言することもできます：

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

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

@Kwargs{key1::Type1, key2::Type2, ...}

このマクロは、@NamedTupleと同じ構文からキーワード引数の型表現を構築する便利な方法を提供します。例えば、func([positional arguments]; kw1=1.0, kw2="2")のような関数呼び出しがある場合、このマクロを使用してキーワード引数の内部型表現を@Kwargs{kw1::Float64, kw2::String}として構築できます。このマクロの構文は、スタックトレースビューに印刷されるときにキーワードメソッドのシグネチャ型を簡素化するように特別に設計されています。

julia> @Kwargs{init::Int} # キーワード引数の内部表現
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
関数 `+` は存在しますが、この引数型の組み合わせに対して定義されたメソッドはありません。

最も近い候補は次のとおりです：
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) where T<:AbstractChar
   @ Base char.jl:237

スタックトレース：
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [インライン]
  [3] _foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, init::Int64, itr::String)
    @ Base ./reduce.jl:62
  [4] foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, nt::Int64, itr::String)
    @ Base ./reduce.jl:48 [インライン]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [インライン]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [インライン]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [インライン]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [インライン]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [インライン]
 [10] トップレベルスコープ
    @ REPL[12]:1

Val(c)

Val{c}()を返します。これはランタイムデータを含みません。このような型は、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} は、型 T の正確に N 個の要素に対応します。最後に、Vararg{T} は型 T のゼロ個以上の要素に対応します。Vararg タプル型は、varargs メソッドが受け入れる引数を表すために使用されます（マニュアルの Varargs Functions セクションを参照してください）。

また、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 の型です。

参照: isnothing, Some, Missing.

isnothing(x)

x === nothing の場合は true を返し、そうでない場合は false を返します。

関連情報として something、Base.notnothing、ismissing を参照してください。

notnothing(x)

x が nothing の場合はエラーをスローし、そうでない場合は x を返します。

Some{T}

Union{Some{T}, Nothing}内で値の欠如（nothing）とnothing値の存在（すなわちSome(nothing)）を区別するために使用されるラッパー型です。

Someオブジェクトによってラップされた値にアクセスするにはsomethingを使用してください。

something(x...)

引数の中で nothing と等しくない最初の値を返します。もし存在しない場合はエラーをスローします。型 Some の引数はアンラップされます。

関連情報として coalesce、skipmissing、@something も参照してください。

例

julia> something(nothing, 1)
1

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

julia> something(Some(nothing), 2) === nothing
true

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("デフォルトの `a` が見つかりません")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("デフォルトの `b` が見つかりません")
f(2)
f(3)
ERROR: デフォルトの `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)は型BaseTypeの整数value1を返します。

列挙のすべてのインスタンスをリストするにはinstancesを使用します。例えば、

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

列挙インスタンスからシンボルを構築することも可能です：

julia> Symbol(apple)
:apple

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

解析されたJuliaコード（AST）における複合式を表す型です。各式は、どの種類の式であるかを識別するhead Symbol（例えば、呼び出し、forループ、条件文など）と、サブ式（例えば、呼び出しの引数）で構成されています。サブ式はargsというVector{Any}フィールドに格納されています。

メタプログラミングに関するマニュアルの章と、開発者向けドキュメントJulia ASTsを参照してください。

例

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

シンボル

解析されたJuliaコード（AST）で識別子を表すために使用されるオブジェクトの型。エンティティを識別するための名前やラベルとしてもよく使用されます（例：辞書のキーとして）。Symbolは:引用演算子を使用して入力できます：

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

Symbolは文字列や他の値から、コンストラクタSymbol(x...)を呼び出すことで構築することもできます。

Symbolは不変であり、同じ名前のすべてのSymbolに対して同じオブジェクトを再利用する実装になっています。

文字列とは異なり、Symbolは文字を反復処理することをサポートしない「原子的」または「スカラー」エンティティです。

Symbol(x...) -> Symbol

引数の文字列表現を連結してSymbolを作成します。

例

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

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

モジュール

モジュールは、別のグローバル変数の作業スペースです。詳細については、moduleおよびモジュールに関するマニュアルセクションを参照してください。

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

指定された名前のモジュールを返します。baremoduleはModule(:ModuleName, false)に対応します。

名前を全く含まない空のモジュールは、Module(:ModuleName, false, false)を使用して作成できます。このモジュールはBaseやCoreをインポートせず、自身への参照を含みません。

関数

すべての関数の抽象型。

例

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (関数 sin の単一型、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 は任意の 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...)

指定された引数 args に対して、指定された型 argtypes に一致する与えられた汎用関数 f のメソッドを呼び出します。引数 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...)に展開します。引数の型注釈が省略されると、その引数のCore.Typeofに置き換えられます。引数が型指定されていないか、明示的にAnyとして型指定されているメソッドを呼び出すには、引数に::Anyで注釈を付けます。

以下の構文もサポートしています：

• @invoke (x::X).fはinvoke(getproperty, Tuple{X,Symbol}, x, :f)に展開されます。
• @invoke (x::X).f = v::Vはinvoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v)に展開されます。
• @invoke (xs::Xs)[i::I]はinvoke(getindex, Tuple{Xs,I}, xs, i)に展開されます。
• @invoke (xs::Xs)[i::I] = v::Vはinvoke(setindex!, Tuple{Xs,V,I}, xs, v, i)に展開されます。

例

julia> @macroexpand @invoke f(x::T, y)
:(Core.invoke(f, Tuple{T, Core.Typeof(y)}, x, y))

julia> @invoke 420::Integer % Unsigned
0x00000000000001a4

julia> @macroexpand @invoke (x::X).f
:(Core.invoke(Base.getproperty, Tuple{X, Core.Typeof(:f)}, x, :f))

julia> @macroexpand @invoke (x::X).f = v::V
:(Core.invoke(Base.setproperty!, Tuple{X, Core.Typeof(:f), V}, x, :f, v))

julia> @macroexpand @invoke (xs::Xs)[i::I]
:(Core.invoke(Base.getindex, Tuple{Xs, I}, xs, i))

julia> @macroexpand @invoke (xs::Xs)[i::I] = v::V
:(Core.invoke(Base.setindex!, Tuple{Xs, V, I}, xs, v, i))

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

f(args...; kwargs...)を呼び出しますが、fの最も最近のメソッドが実行されることを保証します。これは、長時間実行されるイベントループや、古いバージョンの関数fを呼び出す可能性のあるコールバック関数など、特定の状況で便利です。（欠点は、invokelatestはfを直接呼び出すよりも若干遅く、結果の型をコンパイラが推論できないことです。）

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

invokelatestを呼び出すための便利な方法を提供します。@invokelatest f(args...; kwargs...)は単にBase.invokelatest(f, args...; kwargs...)に展開されます。

以下の構文もサポートしています：

• @invokelatest x.fはBase.invokelatest(getproperty, x, :f)に展開されます
• @invokelatest x.f = vはBase.invokelatest(setproperty!, x, :f, v)に展開されます
• @invokelatest xs[i]はBase.invokelatest(getindex, xs, i)に展開されます
• @invokelatest xs[i] = vはBase.invokelatest(setindex!, xs, v, i)に展開されます

julia> @macroexpand @invokelatest f(x; kw=kwv)
:(Base.invokelatest(f, x; kw = kwv))

julia> @macroexpand @invokelatest x.f
:(Base.invokelatest(Base.getproperty, x, :f))

julia> @macroexpand @invokelatest x.f = v
:(Base.invokelatest(Base.setproperty!, x, :f, v))

julia> @macroexpand @invokelatest xs[i]
:(Base.invokelatest(Base.getindex, xs, i))

julia> @macroexpand @invokelatest xs[i] = v
:(Base.invokelatest(Base.setindex!, xs, v, i))

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

内部コンストラクタに利用可能な特別な関数で、型の新しいオブジェクトを作成します。形式 new{A,B,...} は、パラメトリック型のパラメータの値を明示的に指定します。詳細については、内部コンストラクタメソッドに関するマニュアルのセクションを参照してください。

|>(x, f)

関数 f を引数 x に適用する中置演算子です。これにより f(g(x)) を x |> g |> f と書くことができます。無名関数と一緒に使用する場合、意図したチェーンを得るために定義の周りに通常は括弧が必要です。

例

julia> 4 |> inv
0.25

julia> [2, 3, 5] |> sum |> inv
0.1

julia> [0 1; 2 3] .|> (x -> x^2) |> sum
14

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> (==(6)∘length).(["apple", "banana", "carrot"])
3-element BitVector:
 0
 1
 1

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

julia> ∘(fs...)(3)
2.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)

は次のように等価です。

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

すなわち、関数を与えると、新しい関数を返し、それは1つの引数を取り、それを元の関数にスプラットします。これは、複数の引数を持つ関数を、単一の引数を期待するコンテキストに渡すためのアダプタとして便利ですが、その単一の引数としてタプルを渡します。

例

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

julia> my_add = splat(+)
splat(+)

julia> my_add((1,2,3))
6

Fix1(f, x)

2つの引数を持つ関数 f の部分適用バージョンを表す型で、最初の引数は値 "x" に固定されています。言い換えれば、Fix1(f, x) は y->f(x, y) と同様に動作します。

関連項目として Fix2 を参照してください。

Fix2(f, x)

2つの引数を持つ関数 f の部分適用バージョンを表す型で、2番目の引数は値 "x" に固定されています。言い換えれば、Fix2(f, x) は y->f(y, x) と同様に動作します。

Core.eval(m::Module, expr)

指定されたモジュール内で式を評価し、結果を返します。

eval(expr)

モジュールのグローバルスコープで式を評価します。すべての Module（baremodule で定義されたものを除く）は、そのモジュール内で式を評価するための独自の1引数の eval 定義を持っています。

@eval [mod,] ex

evalを使用して、値を補間した式を評価します。2つの引数が提供される場合、最初の引数は評価するモジュールです。

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

ファイルを匿名モジュールに読み込み、includeを使用してすべての式を評価し、最後の式の値を返します。オプションのargs引数は、スクリプトの入力引数（すなわち、グローバルARGS変数）を設定するために使用できます。定義（例えば、メソッドやグローバル変数）は匿名モジュール内で評価され、現在のモジュールには影響を与えないことに注意してください。

例

julia> write("testfile.jl", """
           @show ARGS
           1 + 1
       """);

julia> x = evalfile("testfile.jl", ["ARG1", "ARG2"]);
ARGS = ["ARG1", "ARG2"]

julia> x
2

julia> rm("testfile.jl")

esc(e)

マクロから返されたExprのコンテキスト内でのみ有効です。マクロの衛生パスが埋め込まれた変数をgensym変数に変換するのを防ぎます。詳細と例については、マニュアルのメタプログラミング章のマクロセクションを参照してください。

@inbounds(blk)

式内での配列の境界チェックを排除します。

以下の例では、配列 A の要素 i を参照するための範囲内チェックがスキップされ、パフォーマンスが向上します。

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 は関数定義の直前または関数本体内で適用できます。

# 長い定義にアノテーションを付ける
@inline function longdef(x)
    ...
end

# 短い定義にアノテーションを付ける
@inline shortdef(x) = ...

# `do` ブロックが作成する無名関数にアノテーションを付ける
f() do
    @inline
    ...
end

@inline block

block 内の呼び出しがインライン化する価値があることをコンパイラに示します。

# コンパイラは `f` をインライン化しようとします
@inline f(...)

# コンパイラは `f`、`g` および `+` をインライン化しようとします
@inline f(...) + g(...)

@noinline function explicit_noinline(args...)
    # 本体
end

let
    @inline explicit_noinline(args...) # これはインライン化されます
end

@noinline let a0, b0 = ...
    a = @inline f(a0)  # コンパイラはこの呼び出しをインライン化しようとします
    b = f(b0)          # コンパイラはこの呼び出しをインライン化しようとはしません
    return a, b
end

@noinline

コンパイラに関数をインライン化しないようにヒントを与えます。

小さな関数は通常自動的にインライン化されます。小さな関数に@noinlineを使用することで、自動インライン化を防ぐことができます。

@noinlineは関数定義の直前または関数本体内で適用できます。

# 長い形式の定義に注釈を付ける
@noinline function longdef(x)
    ...
end

# 短い形式の定義に注釈を付ける
@noinline shortdef(x) = ...

# `do`ブロックが作成する無名関数に注釈を付ける
f() do
    @noinline
    ...
end

@noinline block

コンパイラにblock内の呼び出しをインライン化しないようにヒントを与えます。

# コンパイラは`f`をインライン化しないように試みます
@noinline f(...)

# コンパイラは`f`、`g`、および`+`をインライン化しないように試みます
@noinline f(...) + g(...)

@inline function explicit_inline(args...)
    # 本体
end

let
    @noinline explicit_inline(args...) # インライン化されません
end

@inline let a0, b0 = ...
    a = @noinline f(a0)  # コンパイラはこの呼び出しをインライン化しようとしません
    b = f(b0)            # コンパイラはこの呼び出しをインライン化しようとします
    return a, b
end

@nospecialize

関数引数名に適用されると、コンパイラに対してその引数の異なる型に対してメソッド実装を特化させず、代わりにその引数の宣言された型を使用するようにヒントを与えます。これは、形式的な引数リスト内の引数や関数本体内の引数に適用できます。引数に適用されると、マクロは引数式全体をラップする必要があります。例えば、@nospecialize(x::Real)や@nospecialize(i::Integer...)のように、引数名だけをラップするのではありません。関数本体で使用される場合、マクロは文の位置にあり、任意のコードの前に出現する必要があります。

引数なしで使用されると、親スコープのすべての引数に適用されます。ローカルスコープでは、これは含まれている関数のすべての引数を意味します。グローバル（トップレベル）スコープでは、これは現在のモジュールでその後に定義されるすべてのメソッドを意味します。

特化は、@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

例

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Float64
└──      return %1
) => Float64

ここで、@nospecialize注釈は次のように等価になります。

f(A::AbstractArray) = invoke(g, Tuple{AbstractArray}, A)

これにより、gのためにネイティブコードのバージョンが1つだけ生成されることが保証されます。これは、任意のAbstractArrayに対して一般的なものです。しかし、特定の戻り型はgとfの両方に対して依然として推論され、これはfとgの呼び出し元の最適化に使用されます。

@specialize

引数の特化ヒントをデフォルトにリセットします。詳細については、@nospecializeを参照してください。

Base.@nospecializeinfer function f(args...)
    @nospecialize ...
    ...
end
Base.@nospecializeinfer f(@nospecialize args...) = ...

コンパイラに@nospecializeされた引数の宣言された型を使用してfを推論するよう指示します。これは、推論中にコンパイラ生成の特殊化の数を制限するために使用できます。

例

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline Base.@nospecializeinfer g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Any
└──      return %1
) => Any

この例では、fはAの各特定の型に対して推論されますが、gは宣言された引数型A::AbstractArrayで一度だけ推論されるため、コンパイラはそれに対して過剰な推論時間を見ない可能性が高く、具体的な戻り値の型を推論できません。@nospecializeinferがなければ、f([1.0])はgの戻り値の型をFloat64として推論し、特殊化コード生成が禁止されているにもかかわらずg(::Vector{Float64})のために推論が実行されたことを示します。

Base.@constprop 設定 [ex]

注釈付き関数のための手続き間定数伝播のモードを制御します。

2つの setting がサポートされています：

• Base.@constprop :aggressive [ex]: 定数伝播を積極的に適用します。戻り値の型が引数の値に依存するメソッドの場合、追加のコンパイル時間のコストを伴って推論結果が改善される可能性があります。
• Base.@constprop :none [ex]: 定数伝播を無効にします。これにより、Juliaが定数伝播に値すると思われる関数のコンパイル時間を短縮できます。一般的なケースは、Bool または Symbol 型の引数やキーワード引数を持つ関数です。

Base.@constprop は、関数定義の直前または関数本体内で適用できます。

# 長形式の定義に注釈を付ける
Base.@constprop :aggressive function longdef(x)
    ...
end

# 短形式の定義に注釈を付ける
Base.@constprop :aggressive shortdef(x) = ...

# `do` ブロックが作成する無名関数に注釈を付ける
f() do
    Base.@constprop :aggressive
    ...
end

gensym([tag])

他の変数名（同じモジュール内）と衝突しないシンボルを生成します。

@gensym

変数のためのgensymシンボルを生成します。例えば、@gensym x yはx = gensym("x"); y = gensym("y")に変換されます。

var

構文 var"#example#" は、Symbol("#example#") という名前の変数を指しますが、#example# は有効なJulia識別子名ではありません。

これは、有効な識別子の構築に関する異なるルールを持つプログラミング言語との相互運用性に役立ちます。たとえば、R 変数 draw.segments を参照するには、Juliaコード内で var"draw.segments" を使用できます。

また、マクロの衛生を経たJuliaソースコードや、通常は解析できない変数名を含むコードを show するためにも使用されます。

この構文はパーサーのサポートを必要とし、通常の文字列マクロ @var_str として実装されるのではなく、パーサーによって直接展開されます。

@goto name

@goto name は、@label name の位置にあるステートメントに無条件でジャンプします。

@label と @goto は、異なるトップレベルのステートメントへのジャンプを作成することはできません。試みるとエラーが発生します。@goto を使用するには、@label と @goto をブロック内に囲む必要があります。

@label name

nameというシンボリックラベルでステートメントにラベルを付けます。このラベルは、@goto nameによる無条件ジャンプの終点を示します。

@simd

@simdを使用して、コンパイラがループの再配置を許可するためにforループに注釈を付けます。

@simd forループで反復されるオブジェクトは、一次元の範囲である必要があります。@simdを使用することで、ループのいくつかの特性を主張しています：

• 繰り返しを任意または重複した順序で実行することが安全であり、特に還元変数に関して考慮されます。
• 還元変数に対する浮動小数点演算は再配置または収束される可能性があり、@simdを使用しない場合とは異なる結果を引き起こす可能性があります。

多くの場合、Juliaは@simdを使用せずに内部のforループを自動的にベクトル化することができます。@simdを使用することで、コンパイラはより多くの状況でそれを可能にするための少し余裕を持つことができます。いずれの場合でも、内部ループはベクトル化を許可するために以下の特性を持っている必要があります：

• ループは最も内側のループでなければなりません。
• ループ本体は直線的なコードでなければなりません。したがって、@inboundsはすべての配列アクセスに現在必要です。コンパイラは、すべてのオペランドを無条件に評価することが安全である場合、短い&&、||、および?:の式を直線的なコードに変換することがあります。ループ内で安全に行える場合は、?:の代わりにifelse関数を使用することを検討してください。
• アクセスはストライドパターンを持っている必要があり、「ギャザー」（ランダムインデックスの読み取り）や「スキャッター」（ランダムインデックスの書き込み）ではあってはなりません。
• ストライドは単位ストライドである必要があります。

• ループキャリードメモリ依存性は存在しない
• どの反復も前の反復が前進するのを待つことはありません。

@polly

コンパイラにポリヘドラル最適化ツールPollyを関数に適用するよう指示します。

@generated f

@generated は生成される関数に注釈を付けるために使用されます。生成された関数の本体では、引数の値ではなく、引数の型のみを読み取ることができます。この関数は、関数が呼び出されたときに評価される引用された式を返します。@generated マクロは、グローバルスコープを変更する関数や可変要素に依存する関数には使用すべきではありません。

詳細については、Metaprogramming を参照してください。

例

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

julia> bar(4)
16

julia> bar("baz")
"baz"

Base.@assume_effects 設定... [ex]

コンパイラの効果モデリングをオーバーライドします。このマクロは、いくつかのコンテキストで使用できます。

1. メソッド定義の直前に、適用されたメソッドの全体的な効果モデリングをオーバーライドするために。
2. 引数なしの関数本体内で、囲むメソッドの全体的な効果モデリングをオーバーライドするために。
3. コードブロックに適用して、適用されたコードブロックのローカルな効果モデリングをオーバーライドするために。

例

julia> Base.@assume_effects :terminates_locally function fact(x)
           # 使用例 1:
           # この :terminates_locally により `fact` が定数折りたたみ可能になります
           res = 1
           0 ≤ x < 20 || error("bad fact")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (generic function with 1 method)

julia> code_typed() do
           fact(12)
       end |> only
CodeInfo(
1 ─     return 479001600
) => Int64

julia> code_typed() do
           map((2,3,4)) do x
               # 使用例 2:
               # この :terminates_locally によりこの無名関数が定数折りたたみ可能になります
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("bad fact")
               while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

julia> code_typed() do
           map((2,3,4)) do x
               res = 1
               0 ≤ x < 20 || error("bad fact")
               # 使用例 3:
               # この :terminates_locally アノテーションによりコンパイラは汚染をスキップします
               # この `while` ブロック内の `:terminates` 効果を許可し、親
               # 無名関数が定数折りたたみ可能になります
               Base.@assume_effects :terminates_locally while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

一般に、各 setting 値は、関数の動作に関する主張を行いますが、コンパイラにその動作が実際に真であることを証明させる必要はありません。これらの主張はすべてのワールドエイジに対して行われます。したがって、後で拡張されて仮定を無効にする可能性のある一般的な関数の使用を制限することが推奨されます（これにより未定義の動作が引き起こされる可能性があります）。

以下の setting がサポートされています。

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :terminates_locally
• :notaskstate
• :inaccessiblememonly
• :noub
• :noub_if_noinbounds
• :nortcall
• :foldable
• :removable
• :total

拡張ヘルプ

:consistent

:consistent 設定は、等価 (===) 入力に対して次のことを主張します：

• 終了の方法（戻り値、例外、非終了）は常に同じです。
• メソッドが戻る場合、結果は常に等価です。

:effect_free

:effect_free 設定は、メソッドが外部的に意味的に可視な副作用がないことを主張します。以下は、外部的に意味的に可視な副作用の不完全なリストです：

• グローバル変数の値を変更すること。
• ヒープを変更すること（例：配列や可変値）、ただし以下に記載されている場合を除く。
• メソッドテーブルを変更すること（例：eval への呼び出しを通じて）。
• ファイル/ネットワーク/etc. I/O。
• タスクの切り替え。

ただし、以下は明示的に意味的に可視ではありませんが、観察可能である場合があります：

• メモリ割り当て（可変および不変の両方）。
• 経過時間。
• ガーベジコレクション。
• メソッドのライフタイムを超えないオブジェクトのヒープの変更（すなわち、メソッド内で割り当てられ、エスケープしないもの）。
• 戻り値（外部的に可視ですが、副作用ではありません）。

ここでのルールは、外部的に可視な副作用は、関数が実行されなかった場合にプログラムの残りの部分の実行に影響を与えるものです。

:nothrow

:nothrow 設定は、このメソッドが例外をスローしないこと（すなわち、常に値を返すか、決して返さないこと）を主張します。

:terminates_globally

:terminates_globally 設定は、このメソッドが最終的に終了すること（通常または異常に）を主張します。すなわち、無限ループに陥らないことを意味します。

:terminates_locally

:terminates_locally 設定は :terminates_globally と似ていますが、アノテーションされたメソッド内の構文的制御フローにのみ適用されます。したがって、メソッドが他のメソッドを呼び出す場合に非終了の可能性を許可する、はるかに弱い（したがって安全な）主張です。

:notaskstate

:notaskstate 設定は、メソッドがローカルタスク状態（タスクローカルストレージ、RNG状態など）を使用または変更せず、したがってタスク間で安全に移動できることを主張します。

:inaccessiblememonly

:inaccessiblememonly 設定は、メソッドが外部からアクセス可能な可変メモリにアクセスまたは変更しないことを主張します。これは、メソッドが他のメソッドやトップレベルの実行から戻る前にアクセスできない新しく割り当てられたオブジェクトの可変メモリにアクセスまたは変更できることを意味しますが、引数によって指される可変グローバル状態やメモリにはアクセスまたは変更できません。

:noub

:noub 設定は、メソッドが未定義の動作を実行しないことを主張します（任意の入力に対して）。未定義の動作は、技術的には他の効果の主張（たとえば :consistent や :effect_free）を違反させる可能性がありますが、これをモデル化することはなく、未定義の動作が存在しないことを前提としています。

:nortcall

:nortcall 設定は、メソッドが Core.Compiler.return_type を呼び出さず、このメソッドが呼び出す可能性のある他のメソッドも Core.Compiler.return_type を呼び出さないことを主張します。

:foldable

この設定は、コンパイラがコンパイル時に呼び出しを定数折りたたみすることを保証するために必要な効果のセットの便利なショートカットです。現在、次の setting と同等です：

• :consistent
• :effect_free
• :terminates_globally
• :noub
• :nortcall

:removable

この設定は、コンパイラがコンパイル時に未使用の結果を持つ呼び出しを削除することを保証するために必要な効果のセットの便利なショートカットです。現在、次の setting と同等です：

• :effect_free
• :nothrow
• :terminates_globally

:total

この setting は、可能な最大の効果のセットです。現在、次の他の setting を含意します：

• :consistent
• :effect_free
• :nothrow
• :terminates_globally
• :notaskstate
• :inaccessiblememonly
• :noub
• :nortcall

否定された効果

効果名は ! で接頭辞を付けることができ、効果が以前のメタ効果から削除されるべきことを示します。たとえば、:total !:nothrow は、呼び出しが一般的には全体的であるが、スローする可能性があることを示します。 ```

@deprecate old new [export_old=true]

メソッド old を非推奨にし、置き換え呼び出し new を指定し、その過程で指定されたシグネチャを持つ新しいメソッド old を定義します。

old がエクスポートされないようにするには、export_old を false に設定します。

詳細は Base.depwarn() を参照してください。

例

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)

明示的な型アノテーションなしでの @deprecate への呼び出しは、任意の数の位置引数およびキーワード引数を Any 型で受け入れる非推奨メソッドを定義します。

特定のシグネチャに非推奨を制限するには、old の引数にアノテーションを付けます。例えば、

julia> new(x::Int) = x;

julia> new(x::Float64) = 2x;

julia> @deprecate old(x::Int) new(x);

julia> methods(old)
# 1 method for generic function "old" from Main:
 [1] old(x::Int64)
     @ deprecated.jl:94

これは、new(x::Int) を反映する old(x::Int) というメソッドを定義し、old(x::Float64) メソッドは定義も非推奨にもなりません。

Base.depwarn(msg::String, funcsym::Symbol; force=false)

msgを非推奨警告として印刷します。シンボルfuncsymは呼び出し関数の名前であり、各呼び出し場所に対して非推奨警告が最初にのみ印刷されることを保証するために使用されます。force=trueを設定すると、Juliaが--depwarn=no（デフォルト）で起動されていても、警告が常に表示されるように強制されます。

詳細は@deprecateを参照してください。

例

function deprecated_func()
    Base.depwarn("Don't use `deprecated_func()`!", :deprecated_func)

    1 + 1
end

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)  # `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` はまだ missing です")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` はまだ missing です")
f(2)
f(3)
ERROR: `b` はまだ missing です
[...]

ismissing(x)

xがmissingであるかどうかを示します。

関連情報: skipmissing, isnothing, isnan.

skipmissing(itr)

itr内の要素を反復処理し、missing値をスキップするイテレータを返します。返されるオブジェクトは、itrがインデックス可能であれば、itrのインデックスを使用してインデックス付けできます。欠損値に対応するインデックスは無効であり、keysおよびeachindexによってスキップされ、使用しようとするとMissingExceptionがスローされます。

collectを使用して、itr内の非missing値を含むArrayを取得します。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の場合、プロセスのI/Oストリームはdevnullに向けられます。waitがtrueの場合、I/Oストリームは親プロセスと共有されます。I/Oリダイレクションを制御するにはpipelineを使用してください。

devnull

ストリームリダイレクトで使用され、書き込まれたすべてのデータを破棄します。基本的にはUnixの/dev/nullまたはWindowsのNULと同等です。使用例：

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(exec::Vector{String})

新しい 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(exec) コンストラクタは exec のコピーを作成しないことに注意してください。exec に対するその後の変更は Cmd オブジェクトに反映されます。

Cmd オブジェクトを構築する最も一般的な方法は、コマンドリテラル（バックティック）を使用することです。例えば：

`ls -l`

これを 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 は、指定されていない場合は command の現在設定されている dir（指定されていない場合は現在の作業ディレクトリ）にデフォルト設定されます。

他にも Cmd、addenv、ENV、pwd を参照してください。

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

新しい環境マッピングを指定された Cmd オブジェクトにマージし、新しい Cmd オブジェクトを返します。重複するキーは置き換えられます。command に既に環境値が設定されていない場合、inherit が true の場合は addenv() 呼び出し時の現在の環境を継承します。値が nothing のキーは環境から削除されます。

関連情報としては、Cmd、setenv、ENV があります。

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

一時的に変更された（setenvのように置き換えられるのではなく）環境でfを実行します。kvはゼロ個以上の"var"=>val引数です。withenvは一般的にwithenv(kv...) do ... end構文を介して使用されます。nothingの値を使用して、環境変数を一時的に解除することができます（設定されている場合）。withenvが返ると、元の環境が復元されます。

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

commandのCPUアフィニティをCPU IDのリスト（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, ...)

データソースから宛先へのパイプラインを作成します。ソースと宛先はコマンド、I/Oストリーム、文字列、または他のpipeline呼び出しの結果であることができます。少なくとも1つの引数はコマンドでなければなりません。文字列はファイル名を指します。2つ以上の引数で呼び出された場合、それらは左から右に連結されます。例えば、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 へのまたはからの I/O をリダイレクトします。キーワード引数は、リダイレクトすべきコマンドのストリームを指定します。append はファイル出力がファイルに追加されるかどうかを制御します。これは、2引数の pipeline 関数のより一般的なバージョンです。pipeline(from, to) は、from がコマンドの場合は pipeline(from, stdout=to) と同等であり、from が別の種類のデータソースの場合は pipeline(to, stdin=from) と同等です。

例:

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

gethostname() -> String

ローカルマシンのホスト名を取得します。

getpid() -> Int32

JuliaのプロセスIDを取得します。

getpid(process) -> Int32

子プロセスIDを取得します。プロセスがまだ存在する場合に限ります。

time() -> Float64

エポックからの秒数でシステム時間を取得し、かなり高い（通常はマイクロ秒）解像度を持っています。

time_ns() -> UInt64

ナノ秒単位の時間を取得します。0に対応する時間は未定義で、5.8年ごとにラップします。

@time expr
@time "description" expr

式を実行し、その実行にかかった時間、割り当ての数、および実行によって割り当てられた合計バイト数を印刷し、式の値を返すマクロです。ガーベジコレクション（gc）、新しいコードのコンパイル、または無効化されたコードの再コンパイルにかかった時間は、パーセンテージとして表示されます。ReentrantLock が待機しなければならなかったロックの競合は、カウントとして表示されます。

オプションで、時間レポートの前に印刷する説明文字列を提供できます。

場合によっては、システムは @time 式の内部を調べ、トップレベルの式の実行が始まる前に呼び出されたコードの一部をコンパイルします。その場合、一部のコンパイル時間はカウントされません。この時間を含めるには、@time @eval ... を実行できます。

他に @showtime、@timev、@timed、@elapsed、@allocated、および @allocations も参照してください。

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 秒 (2.19 M 割り当て: 116.555 MiB, 3.75% gc 時間, 99.94% コンパイル時間)

julia> @time x * x;
  0.000009 秒 (1 割り当て: 896 バイト)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 秒 (8 割り当て: 336 バイト)
2

julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 秒 (5 割り当て: 144 バイト)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 秒 (5 割り当て: 144 バイト)
2: 1.001263 秒 (5 割り当て: 144 バイト)
3: 1.003676 秒 (5 割り当て: 144 バイト)

@showtime expr

@timeと似ていますが、参照のために評価されている式も印刷します。

関連情報として@timeを参照してください。

julia> @showtime sleep(1)
sleep(1): 1.002164秒 (4回のアロケーション: 128バイト)

@timev expr
@timev "description" expr

これは@timeマクロの詳細版です。最初に@timeと同じ情報を印刷し、その後に非ゼロのメモリ割り当てカウンタを表示し、最後に式の値を返します。

オプションで、時間レポートの前に印刷する説明文字列を提供できます。

他に@time、@timed、@elapsed、@allocated、および@allocationsも参照してください。

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

式を実行し、その式の値、経過時間（秒）、合計バイト数、ガーベジコレクション時間、さまざまなメモリアロケーションカウンタを持つオブジェクト、コンパイル時間（秒）、および再コンパイル時間（秒）を返すマクロです。 ReentrantLock が待機しなければならなかったロックの競合は、カウントとして表示されます。

場合によっては、システムは @timed 式の内部を調べ、トップレベルの式の実行が始まる前に呼び出されたコードの一部をコンパイルします。その場合、一部のコンパイル時間はカウントされません。この時間を含めるには、@timed @eval ... を実行できます。

他に @time、@timev、@elapsed、@allocated、@allocations、および @lock_conflicts も参照してください。

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

julia> stats.compile_time
0.0

julia> stats.recompile_time
0.0

@elapsed

式を評価し、結果の値を破棄し、実行にかかった秒数を浮動小数点数として返すマクロです。

場合によっては、システムは @elapsed 式の内部を調べ、トップレベルの式の実行が始まる前に呼び出されたコードの一部をコンパイルします。その場合、一部のコンパイル時間はカウントされません。この時間を含めるには、@elapsed @eval ... を実行できます。

他に @time、@timev、@timed、@allocated、および @allocations も参照してください。

julia> @elapsed sleep(0.3)
0.301391426

@allocated

式を評価し、結果の値を破棄して、式の評価中に割り当てられた合計バイト数を返すマクロです。

他に @allocations、@time、@timev、@timed、および @elapsed も参照してください。

julia> @allocated rand(10^6)
8000080

@allocations

式を評価し、結果の値を破棄し、代わりに式の評価中に行われた合計のアロケーション数を返すマクロです。

他に @allocated、@time、@timev、@timed、および @elapsed も参照してください。

julia> @allocations rand(10^6)
2

@lock_conflicts

式を評価し、結果の値を破棄し、代わりに評価中のロック競合の総数を返すマクロです。ここで、ReentrantLock に対するロック試行が、ロックがすでに保持されているために待機を引き起こしました。

@time、@timev、および @timed も参照してください。

julia> @lock_conflicts begin
    l = ReentrantLock()
    Threads.@threads for i in 1:Threads.nthreads()
        lock(l) do
        sleep(1)
        end
    end
end
5

EnvDict() -> EnvDict

この型のシングルトンは、環境変数へのハッシュテーブルインターフェースを提供します。

ENV

シングルトン EnvDict への参照で、システム環境変数への辞書インターフェースを提供します。

（Windowsでは、システム環境変数は大文字と小文字を区別しないため、ENV はすべてのキーを表示、反復、コピーのために大文字に変換します。ポータブルなコードは、変数を大文字と小文字で区別できる能力に依存すべきではなく、表面的に小文字の変数を設定すると大文字の ENV キーになる可能性があることに注意する必要があります。）

例

julia> ENV
Base.EnvDict with "50" entries:
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "username"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

関連情報: withenv, addenv.

Sys.STDLIB::String

stdlib パッケージを含むディレクトリへのフルパスを含む文字列。

Sys.isunix([os])

OSがUnixライクなインターフェースを提供しているかどうかをテストするための述語です。オペレーティングシステムのバリエーションの処理のドキュメントを参照してください。

Sys.isapple([os])

OSがApple Macintosh OS XまたはDarwinの派生であるかどうかをテストするための述語です。オペレーティングシステムのバリエーションの処理のドキュメントを参照してください。

Sys.islinux([os])

OSがLinuxの派生であるかどうかをテストするための述語。詳細はオペレーティングシステムのバリエーションの処理を参照してください。

Sys.isbsd([os])

OSがBSDの派生であるかどうかをテストするための述語。詳細はOperating System Variationの取り扱いを参照してください。

Sys.isfreebsd([os])

FreeBSDの派生であるかどうかをテストするための述語です。詳細はOperating System Variationの取り扱いを参照してください。

Sys.isopenbsd([os])

OpenBSDの派生であるかどうかをテストするための述語。詳細はOperating System Variationの取り扱いを参照してください。

Sys.isnetbsd([os])

NetBSDの派生であるかどうかをテストするための述語。詳細はOperating System Variationの取り扱いを参照してください。

Sys.isdragonfly([os])

DragonFly BSDの派生であるかどうかをテストするための述語。詳細はOperating System Variationの取り扱いを参照してください。

Sys.iswindows([os])

Microsoft Windows NT の派生であるかどうかをテストするための述語です。詳細は Handling Operating System Variation のドキュメントを参照してください。

Sys.windows_version()

Windows NTカーネルのバージョン番号をVersionNumberとして返します。つまり、v"major.minor.build"の形式で、Windows上で実行されていない場合はv"0.0.0"を返します。

Sys.free_memory()

RAMの合計空きメモリをバイト単位で取得します。

Sys.total_memory()

RAMの合計メモリ（現在使用中のものを含む）をバイト単位で取得します。この量は、Linuxコントロールグループなどによって制約される場合があります。制約のない量については、Sys.total_physical_memory()を参照してください。

Sys.free_physical_memory()

システムの空きメモリをバイト単位で取得します。全体の量が現在のプロセスに利用可能であるとは限りません。実際に利用可能な量を取得するには Sys.free_memory() を使用してください。

Sys.total_physical_memory()

RAMの合計メモリ（現在使用中のものを含む）をバイト単位で取得します。全体の量が現在のプロセスに利用可能であるとは限りません。Sys.total_memory()を参照してください。

Sys.uptime()

現在のシステムの稼働時間を秒単位で取得します。

Sys.isjsvm([os])

JavaScript VM (JSVM) で Julia が実行されているかどうかをテストするための述語。例えば、ウェブブラウザ内の WebAssembly JavaScript 埋め込みなどが含まれます。

Sys.loadavg()

負荷平均を取得します。参照: https://en.wikipedia.org/wiki/Load_(computing).

isexecutable(path::String)

指定された path に実行権限がある場合は true を返します。

他にも ispath、isreadable、iswritable を参照してください。

isreadable(path::String)

指定された path のアクセス権が現在のユーザーによる読み取りを許可している場合は true を返します。

関連情報として ispath、isexecutable、iswritable を参照してください。

isreadable(io) -> Bool

指定されたIOオブジェクトが読み取り可能でない場合はfalseを返します。

例

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")

iswritable(path::String)

与えられた path のアクセス権が現在のユーザーによる書き込みを許可している場合は true を返します。

関連情報として ispath、isexecutable、isreadable を参照してください。

iswritable(io) -> Bool

指定された IO オブジェクトが書き込み可能でない場合は false を返します。

例

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")

Sys.username() -> String

現在のユーザーのユーザー名を返します。ユーザー名を特定できない場合や空の場合、この関数はエラーをスローします。

環境変数（例：USER）を介して上書き可能なユーザー名を取得するには、次のようにします。

user = get(Sys.username, ENV, "USER")

関連情報はhomedirを参照してください。

@static

パース時に式を部分的に評価します。

例えば、@static Sys.iswindows() ? foo : bar は Sys.iswindows() を評価し、式に foo または bar のいずれかを挿入します。これは、他のプラットフォームでは無効な構文になる場合に便利です。例えば、存在しない関数への ccall のような場合です。@static if Sys.isapple() foo end および @static foo <&&,||> bar も有効な構文です。

VersionNumber

セマンティックバージョニング（semver）の仕様に従ったバージョン番号タイプで、メジャー、マイナー、パッチの数値値で構成され、プレリリースおよびビルドの英数字注釈が続きます。

VersionNumberオブジェクトは、すべての標準比較演算子（==、<、<=など）で比較でき、その結果はsemverルールに従います。

VersionNumberには以下の公開フィールドがあります：

• v.major::Integer
• v.minor::Integer
• v.patch::Integer
• v.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}
• v.build::Tuple{Vararg{Union{Integer, AbstractString}}}

効率的にsemver形式のリテラル文字列からVersionNumberオブジェクトを構築するための@v_str、Julia自体のVersionNumberについてはVERSION、マニュアルのバージョン番号リテラルも参照してください。

例

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

string(msg...)で構築されたメッセージを持つErrorExceptionを発生させます。

throw(e)

オブジェクトを例外としてスローします。

参照: rethrow, error.

rethrow()

catch ブロック内から現在の例外を再スローします。再スローされた例外は、捕捉されなかったかのように伝播を続けます。

backtrace()

現在のプログラムポイントのバックトレースオブジェクトを取得します。

catch_backtrace()

現在の例外のバックトレースを取得し、catch ブロック内で使用します。

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

現在処理中の例外のスタックを取得します。ネストされたキャッチブロックがある場合、現在の例外が複数存在する可能性があり、その場合、最も最近投げられた例外がスタックの最後にあります。スタックは ExceptionStack として返され、これは名前付きタプル (exception,backtrace) の AbstractVector です。backtrace が false の場合、各ペアのバックトレースは nothing に設定されます。

task を明示的に渡すと、任意のタスクの現在の例外スタックが返されます。これは、未処理の例外によって失敗したタスクを調査するのに便利です。

@assert cond [text]

condがfalseの場合、AssertionErrorをスローします。これは、真であると仮定される条件であるアサーションを書くための推奨構文ですが、ユーザーが失敗した場合のデバッグの助けとしてチェックすることを決定するかもしれません。オプションのメッセージtextは、アサーションの失敗時に表示されます。

例

julia> @assert iseven(3) "3は奇数です！"
ERROR: AssertionError: 3は奇数です！

julia> @assert isodd(3) "偶数とは一体何ですか？"

Experimental.register_error_hint(handler, exceptiontype)

「ヒント」関数 handler(io, exception) を登録します。この関数は、ユーザーがエラーを回避するための潜在的な方法を提案することができます。 handler は exception を調べて、ヒントに適した条件が満たされているかどうかを確認し、そうであれば io に出力を生成します。パッケージは、__init__ 関数内から register_error_hint を呼び出すべきです。

特定の例外タイプに対して、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
                    # 色は必要ありません、これは可能であることを示すためだけです。
                    print(io, "\n呼び出そうとしましたか ")
                    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)
関数 `only_int` は存在しますが、この引数タイプの組み合わせに対して定義されたメソッドはありません。
`any_number` を呼び出そうとしましたか？
最も近い候補は：
    ...

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

特定の例外タイプ typeof(ex) に対して Experimental.register_error_hint からすべてのハンドラーを呼び出します。 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

Taskによってスローされた例外のVectorをラップし（例えば、チャネルを介してリモートワーカーから生成されたものや、非同期に実行されるローカルI/O書き込み、またはpmapの下でのリモートワーカーからのもの）、例外の系列に関する情報を提供します。例えば、複数のワーカーがいくつかのタスクを実行していて、複数のワーカーが失敗した場合、結果として得られるCompositeExceptionは、各ワーカーからの情報の「バンドル」を含み、例外が発生した場所と理由を示します。

DimensionMismatch([msg])

呼び出されたオブジェクトの次元が一致していません。オプションの引数 msg は、説明的なエラーストリングです。

DivideError()

整数除算が分母の値が 0 の場合に試みられました。

例

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: 整数除算エラー
Stacktrace:
[...]

DomainError(val)
DomainError(val, msg)

関数またはコンストラクタへの引数 val が有効なドメインの外にあります。

例

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrtは負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。sqrt(Complex(x))を試してください。
Stacktrace:
[...]

EOFError()

ファイルまたはストリームから読み取るためのデータがもうありませんでした。

ErrorException(msg)

一般的なエラータイプです。.msgフィールドにあるエラーメッセージは、より具体的な詳細を提供する場合があります。

例

julia> ex = ErrorException("私は悪いことをしました");

julia> ex.msg
"私は悪いことをしました"

InexactError(name::Symbol, T, val)

valを関数nameのメソッドの型Tに正確に変換できません。

例

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

InterruptException()

プロセスはターミナルの中断（CTRL+C）によって停止されました。

-i（インタラクティブ）オプションなしで開始されたJuliaスクリプトでは、InterruptExceptionはデフォルトではスローされないことに注意してください。スクリプト内でBase.exit_on_sigint(false)を呼び出すことで、REPLの動作を回復できます。あるいは、次のようにJuliaスクリプトを開始することもできます。

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

これにより、実行中にCTRL+CによってInterruptExceptionがスローされるようになります。

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

プロセスの問題のある終了ステータスを示します。コマンドやパイプラインを実行しているときに、非ゼロの終了コードが返されたことを示すためにスローされます（つまり、呼び出されたプロセスが失敗したことを示します）。

TaskFailedException

この例外は、タスク t が失敗したときに wait(t) 呼び出しによってスローされます。TaskFailedException は失敗したタスク t をラップします。

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, [scope])

現在のスコープにシンボルが定義されていません。

例

julia> a
ERROR: UndefVarError: `a` not defined in `Main`

julia> a = 1;

julia> a
1

StringIndexError(str, i)

iが無効なインデックスであるため、strにアクセスしようとしたときにエラーが発生しました。

InitError(mod::Symbol, error)

モジュールの __init__ 関数を実行中にエラーが発生しました。実際にスローされたエラーは .error フィールドで確認できます。

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

関数 f を呼び出す無名関数を返します。例外が発生した場合、check が true を返すたびに、delays で指定された秒数待った後に f が再度呼び出されます。check は delays の現在の状態と Exception を入力する必要があります。