Essentials

exit(code=0)

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

atexit(f)

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

f に一つの整数引数のメソッドが定義されている場合、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)

入力ソースファイルの内容を、含まれているモジュールのグローバルスコープで評価します。すべてのModule（baremoduleで定義されたものを除く）は、ファイルをそのモジュール内で評価するためのプライベートな1引数の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 ライブラリのランタイム初期化関数を呼び出すことと、外部ライブラリによって返されるポインタを含むグローバル定数を初期化することです。詳細については、modules に関するマニュアルセクションを参照してください。

関連情報: OncePerProcess.

例

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

OncePerProcess{T}(init::Function)() -> T

OncePerProcessオブジェクトを呼び出すと、関数initializerをプロセスごとに正確に1回実行することで、型Tの値が返されます。同じプロセス内のすべての同時および将来の呼び出しは、正確に同じ値を返します。これは、キャッシュやシリアル化されない他の状態を設定できるため、事前コンパイルされるコードで便利です。

例

julia> const global_state = Base.OncePerProcess{Vector{UInt32}}() do
           println("Lazy global valueを作成中...完了。")
           return [Libc.rand()]
       end;

julia> (procstate = global_state()) |> typeof
Lazy global valueを作成中...完了。
Vector{UInt32} (alias for Array{UInt32, 1})

julia> procstate === global_state()
true

julia> procstate === fetch(@async global_state())
true

OncePerTask{T}(init::Function)() -> T

OncePerTaskオブジェクトを呼び出すと、関数initializerをTaskごとに正確に1回実行することで、型Tの値が返されます。同じTask内のすべての将来の呼び出しは、正確に同じ値を返します。

関連情報: task_local_storage.

例

julia> const task_state = Base.OncePerTask{Vector{UInt32}}() do
           println("Lazy task valueを作成中...完了。")
           return [Libc.rand()]
       end;

julia> (taskvec = task_state()) |> typeof
Lazy task valueを作成中...完了。
Vector{UInt32} (alias for Array{UInt32, 1})

julia> taskvec === task_state()
true

julia> taskvec === fetch(@async task_state())
Lazy task valueを作成中...完了。
false

OncePerThread{T}(init::Function)() -> T

OncePerThreadオブジェクトを呼び出すと、関数initializerをスレッドごとに正確に1回実行することで、型Tの値が返されます。同じスレッド内での将来のすべての呼び出し、および同じスレッドIDを持つ同時または将来の呼び出しは、正確に同じ値を返します。このオブジェクトは、既存のスレッドのスレッドIDでインデックスを付けることもでき、そのスレッドに保存されている値を取得（またはこのスレッドで初期化）できます。不適切な使用はデータ競合やメモリ破損を引き起こす可能性があるため、ライブラリのスレッドセーフ設計内でその動作が正しい場合にのみ使用してください。

関連情報: OncePerTask.

例

julia> const thread_state = Base.OncePerThread{Vector{UInt32}}() do
           println("Lazy thread valueを作成中...完了。")
           return [Libc.rand()]
       end;

julia> (threadvec = thread_state()) |> typeof
Lazy thread valueを作成中...完了。
Vector{UInt32} (alias for Array{UInt32, 1})

julia> threadvec === fetch(@async thread_state())
true

julia> threadvec === thread_state[Threads.threadid()]
true

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

projfileにアクティブなProject.tomlファイルを設定します。詳細は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 した際に利用可能にするわけではありません。

export がすでに名前がパブリックであることを示しているため、名前を public と export の両方として宣言することは不必要であり、エラーとなります。詳細については manual section about modules を参照してください。

import

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

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

macroは、生成されたコードをプログラムに挿入するためのメソッドを定義します。マクロは、引数の式のシーケンスを返される式にマッピングし、結果の式はマクロが呼び出されたポイントでプログラムに直接置き換えられます。マクロは、evalを呼び出すことなく生成されたコードを実行する方法であり、生成されたコードは単に周囲のプログラムの一部になります。マクロの引数には、式、リテラル値、およびシンボルが含まれる場合があります。マクロは可変数の引数（varargs）に対して定義できますが、キーワード引数は受け付けません。すべてのマクロは、呼び出された行番号とファイル名を含む__source__引数と、マクロが展開されるモジュールを示す__module__引数が暗黙的に渡されます。

マクロの書き方についての詳細は、Metaprogrammingのマニュアルセクションを参照してください。

例

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 Matrix{Int64}:
 1  2
 3  4

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

end

end は、module、struct、mutable struct、begin、let、for などの式のブロックの結論を示します。

end は、インデックス指定時にコレクションの最後のインデックスや配列の次元の最後のインデックスを表すためにも使用されます。

例

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

julia> A[end, :]
2-element Vector{Int64}:
 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 構文の力は、深くネストされた計算を呼び出し関数のスタックのはるか上のレベルに即座に戻す能力にあります。

try/catch ブロックには、例外が発生しなかった場合にのみ実行される else 節を持つこともできます：

try
    a_dangerous_operation()
catch
    @warn "操作が失敗しました。"
else
    @info "操作が成功しました。"
end

try または try/catch ブロックには、例外が発生したかどうかに関係なく、最後に実行される finally 節を持つこともできます。たとえば、開いたファイルが閉じられることを保証するために使用できます：

f = open("file")
try
    operate_on_file(f)
catch
    @warn "エラーが発生しました！"
finally
    close(f)
end

（finally は catch ブロックなしでも使用できます。）

finally

指定された try コードブロックがどのように終了しても、いくつかのコードを実行します。たとえば、開いたファイルが閉じられることを保証する方法は次のとおりです。

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 は新しいローカル変数を導入します。詳細については、manual section on variable scopingを参照してください。

例

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 がその名前のグローバル変数を参照するようにします。詳細については、manual section on variable scoping を参照してください。

例

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
               # empty
           end
           return i
       end;

julia> f()
0

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

julia> f()
3

julia> i = 0 # グローバル変数
       for outer i = 1:3
       end
ERROR: syntax: no outer local variable declaration exists for "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の式で宣言された型のためにキーワードベースのコンストラクタを自動的に定義するヘルパーマクロです。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:
[...]

abstract type

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

abstract type Number end
abstract type Real <: Number end

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

primitive type

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

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

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

where

where キーワードは 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

;

セミコロンはステートメントの区切りとして使用され、関数の宣言や呼び出しにおけるキーワード引数の始まりを示します。

=

= は代入演算子です。

• 変数 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 Vector{Int64}:
 2

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

関数に渡されたコレクションもコピーされません。関数は引数が参照するオブジェクトの内容を変更（変異）することができます。（このような関数の名前は慣例的に '!' で終わります。）

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

julia> a = [1]; f!(a); a
1-element Vector{Int64}:
 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 Vector{Int64}:
 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 Vector{Int64} at index [3]
[...]

julia> push!(a, 2, 3)
4-element Vector{Int64}:
 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 Vector{Int64}:
 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"

.=

ブロードキャストされた代入を実行します。右側の引数はbroadcastのように展開され、その後左側の引数にインプレースで代入されます。同じ式内の他のドット演算子と融合します。つまり、全体の代入式は単一のループに変換されます。

A .= Bはbroadcast!(identity, A, B)に似ています。

例

julia> A = zeros(4, 4); B = [1, 2, 3, 4];

julia> A .= B
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 2.0  2.0  2.0  2.0
 3.0  3.0  3.0  3.0
 4.0  4.0  4.0  4.0

julia> A
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 2.0  2.0  2.0  2.0
 3.0  3.0  3.0  3.0
 4.0  4.0  4.0  4.0

.

ドット演算子は、オブジェクトのフィールドやプロパティにアクセスしたり、モジュール内で定義された変数にアクセスするために使用されます。

一般に、a.b は getproperty(a, :b) を呼び出します（getpropertyを参照）。

例

julia> z = 1 + 2im; z.im
2

julia> Iterators.product
product (generic function with 1 method)

x -> y

引数 x を関数本体 y にマッピングする匿名関数を作成します。

julia> f = x -> x^2 + 2x - 1
#1 (generic function with 1 method)

julia> f(2)
7

匿名関数は複数の引数に対しても定義できます。

julia> g = (x,y) -> x^2 + y^2
#2 (generic function with 1 method)

julia> g(2,3)
13

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

::

:: 演算子は、値が指定された型を持つことを主張するか、ローカル変数または関数の戻り値が常に指定された型を持つことを宣言します。

expression::T の場合、まず expression が評価されます。結果が型 T の場合、値は単に返されます。そうでない場合、TypeError がスローされます。

ローカルスコープでは、構文 local x::T または x::T = expression は、ローカル変数 x が常に型 T を持つことを宣言します。変数に値が割り当てられると、その値は convert を呼び出すことによって型 T に変換されます。

メソッド宣言では、構文 function f(x)::T により、メソッドによって返される任意の値が型 T に変換されます。

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

例

julia> (1+2)::AbstractFloat
ERROR: TypeError: typeassert: expected AbstractFloat, got a value of type Int64

julia> (1+2)::Int
3

julia> let
           local x::Int
           x = 2.0
           x
       end
2

[]

角括弧は、インデックス付け (getindex)、インデックス付き代入 (setindex!)、配列リテラル (Base.vect)、配列の連結 (vcat、hcat、hvcat、hvncat)、および配列内包表記 (collect)に使用されます。

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マクロを提供します。

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

イテレータと作業するためのメソッド。

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)

引数を x と比較する関数を作成します。これは isequal を使用し、すなわち y -> isequal(y, x) に相当する関数です。

返される関数は Base.Fix2{typeof(isequal)} 型であり、特化したメソッドを実装するために使用できます。

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

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, ::Val{N})

長さ N のタプルを作成し、各要素を f(i) として計算します。ここで、i は要素のインデックスです。Val(N) 引数を取ることで、このバージョンの ntuple は整数として長さを取るバージョンよりも効率的なコードを生成する可能性があります。しかし、N がコンパイル時に決定できない場合は、ntuple(f, Val(N)) よりも ntuple(f, N) の方が好ましいです。

例

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

ntuple(f, n::Integer)

長さ n のタプルを作成し、各要素を f(i) として計算します。ここで、i は要素のインデックスです。

例

julia> ntuple(i -> 2*i, 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](@ref））も実装する必要があります。

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

julia> a = hash(10)
0x95ea2955abd45275

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

参照: objectid, Dict, Set.

finalizer(f, x)

プログラムからアクセス可能な参照が x に対して存在しなくなったときに呼び出される関数 f(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に、egalに従って比較交換操作を行います。関数呼び出し形式の代わりに、構文@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 を使用してください。

グローバル変数のバリアントは、古い Julia リリースとの互換性のためにサポートされています。新しいコードでは、isdefinedglobal を使用することをお勧めします。

他にも @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

isdefinedglobal(m::Module, s::Symbol, [allow_import::Bool=true, [order::Symbol=:unordered]])

モジュール m においてグローバル変数 s が定義されているかどうかをテストします（現在のワールドエイジにおいて）。変数は、グローバル変数から値を読み取ることができ、アクセスが例外をスローしない場合にのみ定義されていると見なされます。これには、定数と値が設定されているグローバル変数の両方が含まれます。

allow_import が false の場合、グローバル変数は m 内で定義されている必要があり、他のモジュールからインポートされてはなりません。

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

例

julia> isdefinedglobal(Base, :sum)
true

julia> isdefinedglobal(Base, :NonExistentMethod)
false

julia> isdefinedglobal(Base, :sum, false)
true

julia> isdefinedglobal(Main, :sum, false)
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           # a reference is maintained via `x`
WeakRef("a string")

julia> x = nothing # clear reference

julia> GC.gc()

julia> w
WeakRef(nothing)

supertype(T::Union{DataType, UnionAll})

型 T の直接のスーパタイプを返します。T は DataType または UnionAll 型であることができます。型 Union はサポートされていません。さらに、Types に関する情報も参照してください。

例

julia> supertype(Int32)
Signed

julia> supertype(Vector)
DenseVector (alias for DenseArray{T, 1} where T)

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

サブタイピング関係は、2つの型の間で定義されます。Juliaにおいて、型 S は型 T の サブタイプ であると言われるのは、S <: T が成り立つ場合のみです。

任意の型 L と任意の型 R に対して、L <: R は、型 L の任意の値 v が型 R の値でもあることを意味します。すなわち、(L <: R) && (v isa L) は v isa R を意味します。

サブタイピング関係は 部分順序 です。すなわち、<: は以下の性質を持ちます：

• 反射的：任意の型 T に対して、T <: T が成り立ちます
• 反対称的：任意の型 A と任意の型 B に対して、(A <: B) && (B <: A) は A == B を意味します
• 推移的：任意の型 A、任意の型 B、および任意の型 C に対して、(A <: B) && (B <: C) は A <: C を意味します

詳細は Types、Union{}、Any、isa の情報を参照してください。

例

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}  # `Matrix` は不変
false

julia> Tuple{Float64} <: Tuple{AbstractFloat}    # `Tuple` は共変
true

julia> Union{} <: Int  # 最下位型 `Union{}` は各型のサブタイプです。
true

julia> Union{} <: Float32 <: AbstractFloat <: Real <: Number <: Any  # 演算子のチェーン
true

<: キーワードは、同じサブタイピング関係を表すいくつかの構文上の使い方も持っていますが、演算子を実行したり Bool を返したりはしません：

• UnionAll 型のパラメータの下限と上限を where 文で指定するため。
• メソッドの (静的) パラメータの下限と上限を指定するため、Parametric Methods を参照してください。
• 新しい型を宣言する際にサブタイピング関係を定義するため、struct と abstract type を参照してください。

>:(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)はFloat64を返しますが、厳密にはすべてのInt64の値が正確にFloat64の値として表現できるわけではありません。

関連情報: promote, promote_typejoin, promote_rule.

例

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia> promote_type(Int16, Float16)
Float16

julia> promote_type(Int64, Float16)
Float16

julia> promote_type(Int8, UInt16)
UInt16

promote_rule(type1, type2)

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のフィールドの名前を持つタプルを取得します。

各名前はSymbolですが、x <: Tupleの場合は、各名前（実際にはフィールドのインデックス）はIntです。

propertynamesやhasfieldも参照してください。

例

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

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

julia> fieldnames(Tuple{String,Int})
(1, 2)

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

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

戻り値の型はSymbolですが、x <: Tupleの場合はフィールドのインデックスが返され、その型はIntです。

例

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

julia> fieldname(Tuple{String,Int}, 2)
2

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

複合データ型 T におけるフィールド（名前またはインデックスで指定）の宣言された型を決定します。

例

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

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

複合データ型 T のすべてのフィールドの宣言された型をタプルとして返します。

例

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

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

指定された型のインスタンスが持つフィールドの数を取得します。この型があまりにも抽象的であるためにこれを決定できない場合、エラーが発生します。

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

Tがnameを自身のフィールドの1つとして持っているかどうかを示すブール値を返します。

関連情報としては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(t::DataType, s::Union{Int,Symbol}) -> Bool

与えられた型 t において、フィールド s が const であるかどうかを判断します。これは、該当フィールドからの読み取りが等しいオブジェクトに対して一貫していることを意味します。特に、範囲外のフィールドはこの定義の下で const と見なされることに注意してください（常に例外をスローするため）。

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

指定されたモジュール m において、グローバルが const であるかどうかを判断します。これは、定数として宣言されたか、または定数バインディングからインポートされたためです。定数性は特定のワールドエイジに特有であるため、この関数の結果はワールドエイジの更新後に保持されるとは限りません。

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

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

sizeof(T::DataType)
sizeof(obj)

与えられた DataType T の標準的なバイナリ表現のサイズ（バイト単位）。または、obj が 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 が「プレーンデータ」型である場合、つまり不変であり、他の値への参照を含まず、primitive 型と他の isbitstype 型のみを含む場合は true を返します。典型的な例としては、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)
14-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)
 (0x0000000000000068, :ioerrno, Int32)

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

この型のインスタンスのメモリアロケーションの最小アライメント。isconcretetypeの任意の型に対して呼び出すことができますが、Memoryの場合はオブジェクト全体ではなく要素のアライメントを返します。

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

この型のインスタンスのフィールドがメモリ内でパッキングされているかどうかを返します。すなわち、間にパディングビットがない状態です（パディングビットとは、インスタンス自体の意味的な値に影響を与えないビットとして定義されます）。これは、任意の isconcretetype に対して呼び出すことができます。

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

この型のインスタンスがgc管理メモリへの参照を含むことができるかどうかを返します。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, S)

与えられた浮動小数点型 T で表現可能な最大の連続整数であり、かつ整数型 S によって表現可能な最大整数を超えない。言い換えれば、これは maxintfloat(T) と typemax(S) の最小値である。

maxintfloat(T=Float64)

与えられた浮動小数点型 T（デフォルトは Float64）で正確に表現される最大の連続整数値の浮動小数点数です。

つまり、maxintfloat は、n+1 が型 T で正確に表現できない最小の正の整数値の浮動小数点数 n を返します。

Integer 型の値が必要な場合は、Integer(maxintfloat(T)) を使用してください。

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

Extended Help

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

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

Union{}

Union{}、型の空の Union は、型システムの ボトム 型です。つまり、各 T::Type に対して、Union{} <: T です。また、部分型演算子のドキュメントも参照してください: <:。

そのため、Union{} は 空/居住していない 型でもあり、値を持たないことを意味します。つまり、各 x に対して、isa(x, Union{}) == false です。

Base.Bottom はそのエイリアスとして定義されており、Union{} の型は Core.TypeofBottom です。

例

julia> isa(nothing, Union{})
false

julia> Union{} <: Int
true

julia> typeof(Union{}) === Core.TypeofBottom
true

julia> isa(Union{}, 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([位置引数]; kw1=1.0, kw2="2")のような関数呼び出しがある場合、このマクロを使用してキーワード引数の内部型表現を@Kwargs{kw1::Float64, kw2::String}として構築できます。マクロの構文は、スタックトレースビューに印刷されるときにキーワードメソッドのシグネチャ型を簡素化するように特別に設計されています。

julia> @Kwargs{init::Int} # キーワード引数の内部表現
Base.Pairs{Symbol, Int64, Nothing, @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 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

フィールドを持たない型で、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("Unable to find default for `a`")
1

julia> b = nothing;

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

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

julia> b === nothing
true

Enum{T<:Integer}

@enumで定義されたすべての列挙型の抽象スーパタイプです。

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

EnumNameという名前のEnum{BaseType}サブタイプを作成し、オプションで割り当てられた値xとyを持つvalue1とvalue2の列挙メンバー値を持ちます。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

Symbol

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

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

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

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

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

Symbol(x...) -> Symbol

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

例

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

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

Module

Moduleは別のグローバル変数ワークスペースです。詳細については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

2つのメソッド 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...)
invoke(f, argtypes::Method, args...; kwargs...)
invoke(f, argtypes::CodeInstance, args...; kwargs...)

指定された引数 args に対して、指定された型 argtypes に一致する与えられた汎用関数 f のメソッドを呼び出します。引数 args は、指定された型 argtypes に準拠している必要があり、すなわち自動的な変換は行われません。このメソッドは、最も特異的な一致メソッド以外のメソッドを呼び出すことを可能にし、より一般的な定義の動作が明示的に必要な場合に便利です（しばしば同じ関数のより特異的なメソッドの実装の一部として）。ただし、これはランタイムがより多くの作業を行う必要があることを意味するため、invoke は通常の呼び出しによる通常のディスパッチよりも遅くなることが一般的です—時にはかなり遅くなることもあります。

自分が書いていない関数に対して invoke を使用する際は注意が必要です。与えられた argtypes に対してどの定義が使用されるかは、関数が特定の argtypes での呼び出しが公開APIの一部であると明示的に述べていない限り、実装の詳細です。例えば、以下の例での f1 と f2 の間の変更は、通常の（非 invoke）呼び出しで呼び出し元からは見えないため、互換性があると見なされます。しかし、invoke を使用すると変更が見えます。

シグネチャの代わりに Method を渡す

argtypes 引数は Method である場合があり、その場合は通常のメソッドテーブルの検索が完全にバイパスされ、与えられたメソッドが直接呼び出されます。この機能が必要なことは稀です。特に、指定された Method が通常のディスパッチ（または通常の invoke）から完全に到達不可能である場合、例えば、より特異的なメソッドによって置き換えられたり完全にカバーされたりしている場合に注意してください。メソッドが通常のメソッドテーブルの一部である場合、この呼び出しは invoke(f, method.sig, args...) に似た動作をします。

シグネチャの代わりに CodeInstance を渡す

argtypes 引数は CodeInstance である場合があり、メソッドの検索と特化の両方をバイパスします。この呼び出しの意味は、CodeInstance の invoke ポインタの関数ポインタ呼び出しに似ています。引数がその親 MethodInstance に一致しない場合や、min_world/max_world 範囲に含まれないワールドエイジから CodeInstance を呼び出すことはエラーです。フィールドに指定された制約に一致しない動作を持つ CodeInstance を呼び出すことは未定義の動作です。owner !== nothing のコードインスタンス（すなわち、外部コンパイラによって生成されたもの）に対しては、プリコンパイルを通過した後に呼び出すことがエラーになる場合があります。これは外部コンパイラプラグインと共に使用するための高度なインターフェースです。

例

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)に展開されます

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

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

|>(x, f)

引数 x に関数 f を適用する中置演算子です。これにより 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 および iterable コレクションの関数を合成するためのスプラッティング ∘(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

Fix{N}(f, x)

関数 f の部分適用バージョンを表す型で、引数 x が位置 N::Int に固定されています。言い換えれば、Fix{3}(f, x) は (y1, y2, y3...; kws...) -> f(y1, y2, x, y3...; kws...) と同様に動作します。

Fix{1}のエイリアスです。Fixを参照してください。

Fix{2}のエイリアスです。Fixを参照してください。

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変数に変換するのを防ぎます。詳細と例については、マニュアルのメタプログラミング章のMacrosセクションを参照してください。

@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 setting [ex]

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

サポートされている setting は2つあります：

• 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 を使用することで、ループのいくつかの特性を主張しています：

• 繰り返しを任意または重複した順序で実行することが安全であり、特に還元変数に関して考慮されます。
• 還元変数に対する浮動小数点演算は再配置または収束させることができ、@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

Extended help

: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_export(x) new(x)
old_export (generic function with 1 method)

julia> @deprecate old_public(x) new(x) false
old_public (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 ペア引数のいずれかです。既存の環境を置き換えるのではなく変更するには、copy(ENV) を通じて 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...)

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

shell_escape(args::Union{Cmd,AbstractString...}; special::AbstractString="")

未エクスポートの shell_escape 関数は、未エクスポートの Base.shell_split() 関数の逆です：文字列またはコマンドオブジェクトを受け取り、特別な文字をエスケープして、Base.shell_split() を呼び出すと元のコマンドの単語の配列が返されるようにします。special キーワード引数は、空白、バックスラッシュ、引用符、ドル記号に加えて特別と見なされる文字を制御します（デフォルト：なし）。

例

julia> Base.shell_escape("cat", "/foo/bar baz", "&&", "echo", "done")
"cat '/foo/bar baz' && echo done"

julia> Base.shell_escape("echo", "this", "&&", "that")
"echo this && that"

shell_split(command::AbstractString)

シェルコマンド文字列をその個々のコンポーネントに分割します。

例

julia> Base.shell_split("git commit -m 'Initial commit'")
4-element Vector{String}:
 "git"
 "commit"
 "-m"
 "Initial commit"

shell_escape_posixly(args::Union{Cmd,AbstractString...})

エクスポートされていない shell_escape_posixly 関数は、文字列またはコマンドオブジェクトを受け取り、特別な文字をエスケープして、posix シェルに引数として渡すのに安全な形式にします。

参照: Base.shell_escape()

例

julia> Base.shell_escape_posixly("cat", "/foo/bar baz", "&&", "echo", "done")
"cat '/foo/bar baz' '&&' echo done"

julia> Base.shell_escape_posixly("echo", "this", "&&", "that")
"echo this '&&' that"

shell_escape_csh(args::Union{Cmd,AbstractString...})
shell_escape_csh(io::IO, args::Union{Cmd,AbstractString...})

この関数は、文字列引数内のメタ文字を引用符で囲み、返される文字列がUnix Cシェル（csh、tcsh）によって解釈されるコマンドラインに挿入できるようにします。各文字列引数は1つの単語を形成します。

POSIXシェルとは異なり、cshは二重引用符で囲まれた文字列内でバックスラッシュを一般的なエスケープ文字として使用することをサポートしていません。したがって、この関数は、メタ文字を含む可能性のある文字列をシングルクォートで囲みますが、シングルクォートを含む部分は代わりにダブルクォートで囲みます。必要に応じて、これらの引用符のタイプを切り替えます。改行文字はバックスラッシュでエスケープされます。

この関数は、入力文字列に改行（"\n"）文字が含まれていない限り、POSIXシェルでも機能するはずです。

参照: Base.shell_escape_posixly()

shell_escape_wincmd(s::AbstractString)
shell_escape_wincmd(io::IO, s::AbstractString)

未エクスポートの shell_escape_wincmd 関数は、Windows cmd.exe シェルのメタ文字をエスケープします。()!^<>&| をエスケープするために ^ を前に置きます。@ は文字列の先頭でのみエスケープされます。" 文字のペアとそれに囲まれた文字列はエスケープされずに通過します。残りの " は ^ でエスケープされ、結果におけるエスケープされていない " 文字の数が偶数であることが保証されます。

cmd.exe はエスケープ文字 ^ と " を処理する前に変数参照（例えば %USER%）を置き換えるため、この関数はパーセント記号 (%) をエスケープしようとはしません。入力に % が含まれていると、結果が使用される場所によっては重大な破損を引き起こす可能性があります。

エスケープできないASCII制御文字（NUL、CR、LF）を含む入力文字列は、ArgumentError 例外を引き起こします。

結果は、CMD.exe /S /C " ... "（周囲の二重引用符ペア付き）によって処理されるコマンド呼び出しの引数として安全に渡すことができ、入力に % が含まれていない場合、ターゲットアプリケーションによってそのまま受け取られます（そうでない場合、この関数は ArgumentError で失敗します）。入力文字列に % が含まれていると、コマンドインジェクションの脆弱性が生じ、cmdの引数としてこの関数の出力の適合性に関する主張が無効になる可能性があるため、さまざまなソースから文字列を組み立てる際には注意が必要です。

この関数は、プロセスパイプラインを構築する際に Cmd に対して windows_verbatim フラグと組み合わせて使用するのに役立ちます。

wincmd(c::String) =
   run(Cmd(Cmd(["cmd.exe", "/s /c \" $c \""]);
           windows_verbatim=true))
wincmd_echo(s::String) =
   wincmd("echo " * Base.shell_escape_wincmd(s))
wincmd_echo("hello $(ENV["USERNAME"]) & the \"whole\" world! (=^I^=)")

ただし、入力文字列 s に % が含まれている場合、引数リストとエコーされたテキストが破損し、任意のコマンドが実行される可能性があります。引数は環境変数として渡すこともでき、これにより % の問題と windows_verbatim フラグの必要性を回避できます：

cmdargs = Base.shell_escape_wincmd("Passing args with %cmdargs% works 100%!")
run(setenv(`cmd /C echo %cmdargs%`, "cmdargs" => cmdargs))

to_print = "All for 1 & 1 for all!"
to_print_esc = Base.shell_escape_wincmd(Base.shell_escape_wincmd(to_print))
run(Cmd(Cmd(["cmd", "/S /C \" break | echo $(to_print_esc) \""]), windows_verbatim=true))

I/Oストリームパラメータ io を使用すると、結果は文字列として返されるのではなく、そこに書き込まれます。

Base.escape_microsoft_c_args()、Base.shell_escape_posixly() も参照してください。

例

julia> Base.shell_escape_wincmd("a^\"^o\"^u\"")
"a^^\"^o\"^^u^\""

escape_microsoft_c_args(args::Union{Cmd,AbstractString...})
escape_microsoft_c_args(io::IO, args::Union{Cmd,AbstractString...})

コレクションの文字列引数を、多くのWindowsコマンドラインアプリケーションに渡すことができる文字列に変換します。

Microsoft Windowsは、コマンドライン全体をアプリケーションに対して単一の文字列として渡します（POSIXシステムとは異なり、シェルはコマンドラインを引数のリストに分割します）。多くのWindows APIアプリケーション（julia.exeを含む）は、Microsoft C/C++ランタイムの規則を使用して、そのコマンドラインを文字列のリストに分割します。

この関数は、これらのルールに互換性のあるパーサーの逆を実装しています。コマンドライン引数をWindows C/C++/Juliaアプリケーションに渡すために、必要に応じてメタ文字であるスペース、TAB、ダブルクォート、バックスラッシュをエスケープまたは引用しながら、コマンドラインに結合します。

また、Base.shell_escape_wincmd()、Base.escape_raw_string()も参照してください。

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

time_ns() -> UInt64

過去の特定の機械依存の任意の時間に対するナノ秒単位の時間を取得します。主な用途は、プログラム実行中の経過時間を測定することです。返される値は、システムが稼働している間は単調であることが保証されており（mod 2⁶⁴）、クロックドリフトやローカルカレンダー時間の変更の影響を受けませんが、システムの再起動やサスペンションを跨いで任意に変化する可能性があります。

（返される時間は常にナノ秒単位ですが、タイミングの解像度はプラットフォームに依存します。）

@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 seconds (4 allocations: 128 bytes)

@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

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

式が関数呼び出しである場合、引数式からの割り当てのみを測定し、関数の呼び出しに伴うオーバーヘッドや提供された引数値での定数伝播を除外するように努めます。それらの影響を含めたい場合、つまり呼び出し元も測定したい場合は、構文 @allocated (()->f(1))() を使用してください。

関数呼び出しは、単純な引数式のみで測定することをお勧めします。例えば、x = []; @allocated f(x) のように、@allocated f([]) の代わりに使用して、測定されるのは f のみであることを明確にします。

より複雑な式の場合、コードはそのまま実行されるため、周囲のコンテキストによる割り当てが発生する可能性があります。例えば、@allocated f(1) と @allocated x = f(1) が異なる結果を返すことがあります。

他にも @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ライクなインターフェースを提供しているかどうかをテストするための述語です。Handling Operating System Variationのドキュメントを参照してください。

Sys.isapple([os])

OSがApple Macintosh OS XまたはDarwinの派生であるかどうかをテストするための述語。詳細はHandling Operating System Variationを参照してください。

Sys.islinux([os])

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

Sys.isbsd([os])

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

Sys.isfreebsd([os])

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

Sys.isopenbsd([os])

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

Sys.isnetbsd([os])

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

Sys.isdragonfly([os])

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

JuliaがJavaScript VM（JSVM）で実行されているかどうかをテストするための述語。例えば、ウェブブラウザ内の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

マクロ展開時に式を部分的に評価します。

これは、ccallのように、特定のケースで無効になる構造がある場合や、インポートされていないパッケージで定義されたマクロの場合に便利です。

@staticは条件を必要とします。条件はif文、三項演算子、または&&、||のいずれかであることができます。条件は、マクロを再帰的に展開し、結果の式を下げて実行することによって評価されます。その後、一致するブランチ（あれば）が返されます。条件の他のすべてのブランチは、マクロ展開される前に削除されます（そして下げられたり実行されたりします）。

例

macOSでのみ有効な式exprを解析したいとします。この問題は、@staticを使って@static if Sys.isapple() expr endで解決できます。macOS用のexpr_appleと他のオペレーティングシステム用のexpr_othersがある場合、@staticを使った解決策は@static Sys.isapple() ? expr_apple : expr_othersになります。

VersionNumber

バージョン番号タイプで、セマンティックバージョニング (semver) の仕様に従い、メジャー、マイナー、パッチの数値値で構成され、プレリリースおよびビルドのアルファベット注釈が続きます。