Essentials
Introduction
Julia Base には、科学技術計算や数値計算に適したさまざまな関数やマクロが含まれていますが、多くの汎用プログラミング言語と同様に、幅広い機能を備えています。機能は、拡充を続けるavailable packagesからも利用できます。関数は以下のトピック別にまとめられています。
一般的な注意事項:
- モジュールの関数を使うには、
import Moduleでモジュールをインポートし、Module.fn(x)で関数を使用します。 - または、
using Moduleを使うと、エクスポートされたすべてのModule関数を現在の名前空間にインポートできます。 - 慣例として、感嘆符(
!)で終わる関数名は、引数を変更します。変更を行う関数(例:sort!)と、変更を行わない関数(sort)の両方が用意されている場合もあります。
Baseおよび標準ライブラリの動作が安定していると見なされるのは、SemVerで定義されているとおり、文書化されている場合に限ります。つまり、Julia documentationに記載され、かつ不安定であるとの注記がないものです。詳しくはAPI FAQを参照してください。
Getting Around
Base.atexit — Function
atexit(f)プロセス終了時に呼び出す、引数を取らないか、引数を1つ取る関数 f() を登録します。atexit() フックは後入れ先出し(LIFO)の順序で呼び出され、オブジェクトのファイナライザーより先に実行されます。
f に整数引数を1つ取るメソッドが定義されている場合は、f(n::Int32) として呼び出されます。ここで、n は現在の終了コードです。それ以外の場合は、f() として呼び出されます。
終了フック内では exit(n) を呼び出せます。この場合、Julia は元の終了コードではなく、終了コード n で終了します。複数の終了フックが exit(n) を呼び出した場合、Julia は exit(n) を呼び出す終了フックのうち、最後に呼び出されたフックに対応する終了コードで終了します。(終了フックは LIFO 順で呼び出されるため、「最後に呼び出された」は「最初に登録された」と同じ意味になります。)
注:すべての終了フックが呼び出された後は、新たな終了フックを登録できません。すべてのフックの実行が完了した後に atexit(f) を呼び出すと、例外がスローされます。この状況は、シャットダウン中も並行して実行されている可能性のあるバックグラウンドの Task から終了フックを登録する場合に発生し得ます。
Base.isinteractive — Function
isinteractive()::BoolJuliaが対話セッションで実行されているかどうかを判定します。
Base.summarysize — Function
Base.summarysize(obj; count = false, exclude=Union{...}, chargeall=Union{...})::Int引数から到達可能な一意なオブジェクトをすべて調べ、それらのメモリ上のサイズ(バイト単位)または占有する割り当て数を返します。
Keyword Arguments
count: false の場合、オブジェクトのメモリ上の合計サイズを返します。true の場合、オブジェクトが占有する割り当て数を返します。exclude: 探索対象から除外するオブジェクトの型を指定します。chargeall: 通常なら除外されるフィールドも含め、すべてのフィールドのサイズを常に計上するオブジェクトの型を指定します。
sizeofも参照してください。
Examples
julia> Base.summarysize(1.0)
8
julia> Base.summarysize(Ref(rand(100)))
848
julia> sizeof(Ref(rand(100)))
8
julia> Base.summarysize(Core.svec(1.0, "testing", true); count=true)
4Base.__precompile__ — Function
__precompile__(isprecompilable::Bool)この関数を呼び出すファイルがプリコンパイル可能かどうかを指定します。デフォルトはtrueです。モジュールまたはファイルを安全にプリコンパイルできない場合は、Juliaがプリコンパイルを試みた際にエラーをスローするよう、__precompile__(false)を呼び出してください。
Base.include — Function
Base.include([mapexpr::Function,] m::Module, path::AbstractString)入力ソースファイルの内容を、モジュール m のグローバルスコープで評価します(baremodule で定義されたモジュールを除く)。各モジュールには、m 引数を省略してファイルをそのモジュール内で評価する、独自の include 定義があります。戻り値は、入力ファイルで最後に評価された式の結果です。インクルード中は、タスクローカルのインクルードパスがファイルの格納ディレクトリに設定されます。include を入れ子で呼び出すと、このパスを基準に検索します。この関数は通常、ソースを対話的に読み込む場合や、複数のソースファイルに分割されたパッケージのファイルをまとめる場合に使用します。
省略可能な第1引数 mapexpr を指定すると、インクルードしたコードを評価前に変換できます。path 内の解析済みの式 expr ごとに、include 関数が実際に評価するのは mapexpr(expr) です。省略した場合、mapexpr の既定値は identity です。
include — Function
include([mapexpr::Function,] path::AbstractString)入力ソースファイルの内容を、包含先モジュールのグローバルスコープで評価します。baremoduleで定義されたものを除き、すべてのModuleには、1引数を取る非公開のinclude定義があります。この定義は、そのモジュール内で使うために、ファイルをそのモジュール内で評価します。戻り値は、入力ファイルで最後に評価された式の結果です。インクルード中は、ファイルを含むディレクトリがタスクローカルのインクルードパスに設定されます。includeを入れ子で呼び出すと、そのパスを基準に検索します。この関数は通常、ソースを対話的に読み込む場合や、複数のソースファイルに分割されたパッケージ内でファイルを結合する場合に使います。引数pathはnormpathを使って正規化されます。これにより、..などの相対パス要素が解決され、/が適切なパス区切り文字に変換されます。
省略可能な第1引数mapexprを使うと、インクルードしたコードを評価する前に変換できます。path内の解析済みの各式exprについて、実際にはinclude関数がmapexpr(expr)を評価します。省略した場合、mapexprの既定値はidentityです。
別のモジュールにファイルを評価するには、Base.includeを使います。
Base.include_string — Function
include_string([mapexpr::Function,] m::Module, code::AbstractString, filename::AbstractString="string")includeと同様ですが、ファイルではなく、指定された文字列からコードを読み込みます。
省略可能な第1引数mapexprを使うと、評価前に含まれるコードを変換できます。code内の解析済み式exprごとに、include_string関数が実際に評価するのはmapexpr(expr)です。省略した場合、mapexprの既定値はidentityです。
Base.include_dependency — Function
include_dependency(path::AbstractString; track_content::Bool=true)モジュール内で、path(相対パスまたは絶対パス)で指定したファイル、ディレクトリ、またはシンボリックリンクがプリコンパイル時の依存関係であることを宣言します。つまり、track_content=true の場合、path の内容が変更されると、モジュールを再コンパイルする必要があります(path がディレクトリの場合、その内容とは join(readdir(path)) を指します)。track_content=false の場合は、path の更新日時 mtime が変更されると、再コンパイルが実行されます。
これは、モジュールが include 経由では使用されないパスに依存している場合にのみ必要です。コンパイル以外では効果はありません。
__init__ — Keyword
__init__モジュール内の__init__()関数は、実行時にそのモジュールが初めて読み込まれた直後に実行されます。この関数は、モジュール内のほかのすべての文が実行された後に、一度だけ呼び出されます。モジュールの読み込みが完了した後に呼び出されるため、サブモジュールの__init__関数が先に実行されます。__init__の典型的な用途として、外部Cライブラリの実行時初期化関数の呼び出しや、外部ライブラリから返されたポインターを含むグローバル定数の初期化があります。詳しくはmanual section about modulesを参照してください。
関連項目: OncePerProcess。
Examples
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
endBase.OncePerProcess — Type
OncePerProcess{T}(init::Function)() -> TOncePerProcess オブジェクトを呼び出すと、関数 initializer がプロセスごとにちょうど1回実行され、その戻り値として型 T の値が返されます。同じプロセス内での並行呼び出しも、その後の呼び出しも、すべてまったく同じ値を返します。これは、事前コンパイルされるコードで便利です。シリアライズされないキャッシュやその他の状態をセットアップできます。
Example
julia> const global_state = Base.OncePerProcess{Vector{UInt32}}() do
println("Making lazy global value...done.")
return [Libc.rand()]
end;
julia> (procstate = global_state()) |> typeof
Making lazy global value...done.
Vector{UInt32} (alias for Array{UInt32, 1})
julia> procstate === global_state()
true
julia> procstate === fetch(@async global_state())
trueBase.OncePerTask — Type
OncePerTask{T}(init::Function)() -> TOncePerTask オブジェクトを呼び出すと、Task ごとに関数 initializer がちょうど 1 回実行され、その戻り値として型 T の値が返されます。同じ Task 内で以降に呼び出した場合は、常にまったく同じ値が返されます。
関連項目: task_local_storage。
Example
julia> const task_state = Base.OncePerTask{Vector{UInt32}}() do
println("Making lazy task value...done.")
return [Libc.rand()]
end;
julia> (taskvec = task_state()) |> typeof
Making lazy task value...done.
Vector{UInt32} (alias for Array{UInt32, 1})
julia> taskvec === task_state()
true
julia> taskvec === fetch(@async task_state())
Making lazy task value...done.
falseBase.OncePerThread — Type
OncePerThread{T}(init::Function)() -> TOncePerThread オブジェクトを呼び出すと、スレッドごとに関数 initializer がちょうど1回実行され、T 型の値が返されます。同じスレッドでの以降の呼び出しや、同じスレッド ID を指定した並行または将来の呼び出しでは、常にまったく同じ値が返されます。また、既存の任意のスレッドの threadid でこのオブジェクトをインデックスすると、そのスレッドに保存された値を取得できます(または、このスレッド上で初期化できます)。誤った使い方はデータ競合やメモリ破損につながる可能性があるため、ライブラリのスレッド安全性の設計上、その動作が適切な場合にのみ使用してください。
Task が必ず1つのスレッドだけで実行されるとは限りません。そのため、ここで返される値は他の値とエイリアスする場合や、プログラムの実行中に変化する場合があります。この関数は将来非推奨になる可能性があります。initializer が yield すると、この呼び出しの後に現在のタスクを実行するスレッドは、呼び出し開始時のスレッドと異なる場合があります。
関連項目: OncePerTask。
Example
julia> const thread_state = Base.OncePerThread{Vector{UInt32}}() do
println("Making lazy thread value...done.")
return [Libc.rand()]
end;
julia> (threadvec = thread_state()) |> typeof
Making lazy thread value...done.
Vector{UInt32} (alias for Array{UInt32, 1})
julia> threadvec === fetch(@async thread_state())
true
julia> threadvec === thread_state[Threads.threadid()]
trueBase.which — Method
which(f, types)指定されたtypesの引数に対して呼び出される、f(Methodオブジェクト)のメソッドを返します。
typesが抽象型の場合は、invokeによって呼び出されるメソッドを返します。
関連項目:parentmodule、@which、@edit。
Base.methods — Function
methods(f, [types], [module])fのメソッドテーブルを返します。
typesを指定すると、型が一致するメソッドの配列を返します。moduleを指定すると、そのモジュールで定義されたメソッドの配列を返します。モジュールのリストは、配列または集合として指定することもできます。
関連項目: which、@which、methodswith。
Base.@show — Macro
@show exs...1つ以上の式とその結果をstdoutに出力し、最後の結果を返します。
Examples
julia> x = @show 1+2
1 + 2 = 3
3
julia> @show x^2 x/2;
x ^ 2 = 9
x / 2 = 1.5Base.MainInclude.ans — Constant
ans対話プロンプトに自動的にインポートされる、最後に計算された値を参照する変数。
Base.MainInclude.err — Constant
err直近にスローされたエラーを参照する変数で、対話プロンプトに自動的にインポートされます。スローされたエラーは、例外のスタックに収集されます。
Base.active_project — Function
active_project()アクティブなProject.tomlファイルのパスを返します。Base.set_active_projectも参照してください。
Base.set_active_project — Function
set_active_project(projfile::Union{AbstractString,Nothing})アクティブなProject.tomlファイルをprojfileに設定します。Base.active_projectも参照してください。
Base.active_manifest — Function
active_manifest()
active_manifest(project_file::AbstractString)アクティブなマニフェストファイル、または指定した project_file に対して使用されるマニフェストファイルのパスを返します。
複数の環境がロードパス上に存在するスタック環境では、スタック内の他の環境のマニフェストではなく、プライマリ(アクティブ)環境のマニフェストファイルのみを返します。スタック環境の詳細については、マニュアルの Environment stacks の節を参照してください。
プロジェクトとマニフェストの違いや、パッケージのロード時に使われる名前の選択肢とその優先順位については、Project environments を参照してください。
Base.active_project、Base.set_active_project も参照してください。
Keywords
Juliaで予約されているキーワードは次のとおりです:baremodule、begin、break、catch、const、continue、do、else、elseif、end、export、false、finally、for、function、global、if、import、let、local、macro、module、quote、return、struct、true、try、using、while。これらのキーワードを変数名として使うことはできません。
次の2語からなる並びも予約されています:abstract type、mutable struct、primitive type。ただし、次の名前の変数は作成できます:abstract、mutable、primitive、type。
最後に、whereはパラメトリックなメソッドや型の定義を書くための中置演算子として解析されます。inとisaは中置演算子として解析されます。publicはトップレベル文の先頭でキーワードとして解析されます。outerは、forループの反復指定において変数のスコープを変更するために使われると、キーワードとして解析されます。また、asは、importまたはusingによってスコープに導入された識別子の名前を変更するキーワードとして使われます。ただし、where、in、isa、outer、asという名前の変数は作成できます。
module — Keyword
modulemodule は Module を宣言します。これは独立したグローバル変数のワークスペースです。モジュール内では、他のモジュールからどの名前を参照可能にするか(インポートによって)を制御できるほか、自分の名前のうち公開するものを export と public によって指定できます。モジュールを使えば、自分のコードが他の人のコードと組み合わせて使われる場合でも、名前の衝突を心配せずにトップレベルの定義を作成できます。詳しくは manual section about modules を参照してください。
Examples
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)")
endexport — Keyword
exportexportは、モジュール内で、どの名前をユーザーが利用できるようにするかをJuliaに伝えるために使われます。たとえば、export fooを使うと、モジュールをusingしたときに、名前fooが利用可能になります。詳しくはmanual section about modulesを参照してください。
public — Keyword
publicpublicは、モジュール内で、どの名前がそのモジュールの公開APIに含まれるかをJuliaに伝えるために使います。たとえば、public fooは、fooという名前が公開されていることを示しますが、usingそのモジュールから利用可能になるわけではありません。
exportはすでに名前が公開されていることを示すため、同じ名前をpublicとexportedの両方で宣言する必要はなく、宣言するとエラーになります。詳しくはmanual section about modulesを参照してください。
import — Keyword
importimport Fooを実行すると、モジュールまたはパッケージFooが読み込まれます。インポートしたモジュールFooの名前には、ドット構文でアクセスできます(例:Foo.fooを使って名前fooにアクセスします)。詳しくはmanual section about modulesを参照してください。
using — Keyword
usingusing Fooを実行すると、モジュールまたはパッケージFooが読み込まれ、exportされた名前を直接使えるようになります。名前は、exportされているかどうかにかかわらず、ドット構文(例:名前fooにアクセスするFoo.foo)でも使えます。詳しくはmanual section about modulesを参照してください。
as — Keyword
asasは、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 — Keyword
baremodulebaremodule は、using Base を含まず、eval と include のローカル定義も持たないモジュールを宣言します。ただし、Core はインポートします。つまり、
module Mod
...
endと同等です。
baremodule Mod
using Base
eval(x) = Core.eval(Mod, x)
include(p) = Base.include(Mod, p)
...
endmacro — Keyword
macromacroは、プログラムに生成コードを挿入するためのメソッドを定義します。マクロは引数式の列を受け取り、返された式を、マクロが呼び出された位置にプログラムへ直接置き換えます。生成コードは周囲のプログラムの一部となるため、マクロを使えばevalを呼び出さずに生成コードを実行できます。マクロの引数には、式、リテラル値、シンボルを指定できます。可変個数の引数(varargs)を受け取るマクロも定義できますが、キーワード引数は受け付けません。また、すべてのマクロには暗黙的に__source__と__module__も渡されます。前者にはマクロの呼び出し元の行番号とファイル名が含まれ、後者はマクロが展開されるモジュールです。
マクロの書き方について詳しくは、マニュアルのMetaprogrammingの節を参照してください。
Examples
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 friendreturn — Keyword
returnreturn 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 は現在のトップレベル式全体を早期に終了します。
begin — Keyword
beginbegin...end はコードブロックを表します。
begin
println("Hello, ")
println("World!")
end通常、begin は必要ありません。function や let などのキーワードは、暗黙的にコードブロックを開始するためです。; も参照してください。
インデックス指定では、コレクションの最初のインデックスや配列の次元の最初のインデックスを表すために、begin を使うこともできます。たとえば、a[begin] は配列 a の最初の要素です。
Examples
julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
1 2
3 4
julia> A[begin, :]
2-element Matrix{Int64}:
1
2let — Keyword
letlet ブロックは新しいハードスコープを作り、必要に応じて新しいローカル束縛を導入します。
other scope constructs と同様に、let ブロックは、新たに導入されたローカル変数を参照できるコードの範囲を定めます。さらに、構文には、let と同じ行に任意で記述できる、カンマ区切りの代入と変数名に関する特別な意味があります。
let var1 = value1, var2, var3 = value3
code
endこの行で導入された変数は let ブロック内のローカル変数となり、代入は順番に評価されます。その際、各右辺は左辺の名前を考慮しないスコープで評価されます。そのため、let x = x のように書くことができます。この場合、2つの x 変数は別個のものであり、左辺は外側のスコープにある x をローカルでシャドーイングします。ローカルスコープに入るたびに新しいローカル変数が作られるため、これは便利なイディオムにもなり得ます。ただし、その違いが観察できるのは、クロージャを介してスコープの外まで存続する変数の場合に限られます。上の例にある var2 のように、代入を伴わない let 変数は、新しいローカル変数を宣言しますが、まだ値には束縛されていません。
一方、begin ブロックも複数の式をまとめますが、スコープを導入せず、特別な代入構文も持ちません。
Examples
以下の関数では、map によって3回繰り返し更新される x が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 ブロックを追加すると、同じ名前を使って(シャドーイングして)いても、各反復で1つずつ、計3つの異なる変数がキャプチャされます。
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
3if — Keyword
if/elseif/elseif/elseif/elseは条件評価を行います。これにより、ブール式の値に応じてコードの一部を評価するかどうかを決められます。if/elseif/else条件構文の構成は次のとおりです。
if x < y
println("x is less than y")
elseif x > y
println("x is greater than y")
else
println("x is equal to y")
end条件式x < yがtrueの場合、対応するブロックが評価されます。そうでない場合は、条件式x > yが評価され、trueであれば対応するブロックが評価されます。どちらの式もtrueでない場合は、elseブロックが評価されます。elseifブロックとelseブロックは省略可能で、elseifブロックは必要な数だけ使用できます。
一部の他の言語とは異なり、条件の型はBoolでなければなりません。条件がBoolに変換可能であるだけでは不十分です。
julia> if 1 end
ERROR: TypeError: non-boolean (Int64) used in boolean contexttry — Keyword
try/catchtry/catch文は、throwがスローするエラー(例外)を捕捉し、プログラムの実行を続行できるようにします。たとえば、次のコードはファイルへの書き込みを試みますが、書き込めない場合は実行を終了せず、ユーザーに警告して処理を続けます。
try
open("/danger", "w") do f
println(f, "Hello")
end
catch
@warn "Could not write file."
endファイルを変数に読み込めない場合は、次のようになります。
lines = try
open("/danger", "r") do f
readlines(f)
end
catch
@warn "File not found."
end構文catch e(eは任意の変数)は、スローされた例外オブジェクトを、指定した変数にcatchブロック内で代入します。
try
a_dangerous_operation()
catch e
if isa(e, EOFError)
@warn "The operation failed - EOF."
elseif isa(e, OutOfMemoryError)
@warn "The operation failed - OOM."
else
rethrow() # ensure other exceptions can bubble up the call stack
end
endtry/catch構文の利点は、深くネストされた計算から、呼び出し関数のスタック上のはるかに高いレベルへ直ちに巻き戻せることです。
try/catchブロックには、例外が発生しなかった場合にのみ実行されるelse節を付けることもできます。
try
a_dangerous_operation()
catch
@warn "The operation failed."
else
@info "The operation succeeded."
endtryブロックまたはtry/catchブロックには、例外が発生したかどうかにかかわらず最後に実行されるfinally節を付けることもできます。たとえば、開いたファイルが必ず閉じられるようにするために使えます。
f = open("file")
try
operate_on_file(f)
catch
@warn "An error occurred!"
finally
close(f)
end(finallyは、catchブロックなしでも使用できます。)
finally — Keyword
finally指定したtryコードブロックがどのように終了しても、その終了時にコードを実行できます。たとえば、開いたファイルが必ず閉じられるようにするには、次のようにします。
f = open("file")
try
operate_on_file(f)
finally
close(f)
endtryブロックから制御が抜けると(たとえば、returnによる場合や、通常どおり処理が完了した場合)、close(f)が実行されます。tryブロックが例外によって終了した場合、その例外は引き続き伝播します。catchブロックは、tryやfinallyと組み合わせることもできます。この場合、エラーがcatchによって処理された後に、finallyブロックが実行されます。
try/catch/else/finally式を評価するとき、式全体の値は、finallyブロックを除き、最後に実行されたブロックの値になります。たとえば、次のようになります。
julia> try
1
finally
2
end
1
julia> try
error("")
catch
1
else
2
finally
3
end
1
julia> try
0
catch
1
else
2
finally
3
end
2local — Keyword
locallocal は新しいローカル変数を導入します。詳しくは manual section on variable scoping を参照してください。
Examples
julia> function foo(n)
x = 0
for i = 1:n
local x # introduce a loop-local x
x = i
end
x
end
foo (generic function with 1 method)
julia> foo(10)
0global — Keyword
globalglobal xを使うと、現在のスコープとその内側のスコープで、xがその名前のグローバル変数を参照するようになります。詳しくはmanual section on variable scopingを参照してください。
Examples
julia> z = 3
3
julia> function foo()
global z = 6 # use the z variable defined outside foo
end
foo (generic function with 1 method)
julia> foo()
6
julia> z
6outer — Keyword
for outerfor ループで、既存のローカル変数を反復処理に再利用します。
詳しくはmanual section on variable scopingをご覧ください。
こちらもご覧ください:for。
Examples
julia> function f()
i = 0
for i = 1:3
# empty
end
return i
end;
julia> f()
0julia> function f()
i = 0
for outer i = 1:3
# empty
end
return i
end;
julia> f()
3julia> i = 0 # global variable
for outer i = 1:3
end
ERROR: syntax: no outer local variable declaration exists for "for outer"
[...]const — Keyword
constconstは、値が変わらないグローバル変数を宣言するために使います。ほとんどのコード、特に性能が重要なコードでは、グローバル変数をこの方法で定数として宣言する必要があります。
const x = 51つのconst内で、複数の変数を宣言できます。
const y, z = 7, 11constは1つの=演算にのみ適用されるため、const x = y = 1ではxは定数として宣言されますが、yは定数として宣言されません。一方、const x = const y = 1では、xとyの両方が定数として宣言されます。
「定数であること」は、変更可能なコンテナの中身には及びません。定数なのは、変数とその値との結び付きだけです。たとえば、xが配列や辞書であれば、要素の変更、追加、削除は引き続き可能です。
場合によっては、const変数の値を変更してもエラーではなく警告が表示されます。しかし、予測できない動作やプログラムの状態の破損につながる可能性があるため、変更は避けてください。この機能は、対話的な使用時の利便性のみを目的としています。
struct — Keyword
structJuliaで最もよく使われる型は、名前とフィールドの集合で定義する構造体です。
struct Point
x
y
endフィールドには型制約を指定できます。また、型パラメーターを使うこともできます。
struct Point{X}
x::X
y::Float64
end構造体では、<:構文を使って抽象スーパータイプを宣言することもできます。
struct Point <: AbstractPoint
x
y
endstructはデフォルトで不変です。これらの型のインスタンスは、構築後に変更できません。インスタンスを変更可能な型を宣言するには、代わりにmutable structを使います。
コンストラクターの定義方法など、詳しくはマニュアルのComposite Typesの節を参照してください。
mutable struct — Keyword
mutable structmutable structはstructに似ていますが、構築後に型のフィールドを設定できる点が異なります。
可変構造体の個々のフィールドにはconstを指定して、不変にできます。
mutable struct Baz
a::Int
const b::Float64
end詳しくは、Composite Typesに関するマニュアルの節を参照してください。
Base.@kwdef — Macro
@kwdef typedefこれは、式 typedef で宣言された型に対して、キーワード引数を使うコンストラクターを自動的に定義するヘルパーマクロです。この式は struct または mutable struct でなければなりません。デフォルト引数は、フィールドを field::T = default または field = default の形式で宣言することで指定します。デフォルト値を指定しない場合、生成される型コンストラクターでは、そのキーワード引数が必須になります。
内部コンストラクターも定義できますが、キーワード外部コンストラクターが正しく機能するには、少なくとも1つはデフォルトの内部コンストラクターと同じ形式(つまり、フィールドごとに1つの位置引数を取る形式)で引数を受け取る必要があります。
Examples
julia> @kwdef struct Foo
a::Int = 1 # specified default
b::String # required keyword
end
Foo
julia> Foo(b="hi")
Foo(1, "hi")
julia> Foo()
ERROR: UndefKeywordError: keyword argument `b` not assigned
Stacktrace:
[...]abstract type — Keyword
abstract typeabstract typeはインスタンス化できない型を宣言します。型グラフのノードとしてのみ機能し、関連する具象型の集合、すなわちその子孫にあたる具象型を表します。抽象型は概念上の階層を形成し、Juliaの型システムを単なるオブジェクト実装の集合以上のものにしています。たとえば、次のようになります。
abstract type Number end
abstract type Real <: Number endprimitive type — Keyword
primitive typeprimitive typeは、データがビット列のみで構成される具象型を宣言します。プリミティブ型の代表例として、整数や浮動小数点数があります。組み込みプリミティブ型の宣言例をいくつか示します。
primitive type Char 32 end
primitive type Bool <: Integer 8 end型名の後の数値は、その型に必要な記憶領域のビット数を示します。現在サポートされているのは、8ビットの倍数のサイズのみです。Bool宣言は、プリミティブ型を任意でスーパータイプのサブタイプとして宣言する方法を示しています。
where — Keyword
wherewhereキーワードはUnionAll型を作成します。この型は、ある変数のすべての値について、ほかの型を反復的に和集合したものと考えることができます。たとえば、Vector{T} where T<:Realには、要素型が何らかのReal数であるすべてのVectorが含まれます。
変数の上限を省略した場合、デフォルトでAnyになります。
Vector{T} where T # short for `where T<:Any`変数には下限を指定することもできます。
Vector{T} where T>:Int
Vector{T} where Int<:T<:Real入れ子になったwhere式を簡潔に記述する構文もあります。たとえば、次の式は
Pair{T, S} where S<:Array{T} where T<:Number次のように短縮できます。
Pair{T, S} where {T<:Number, S<:Array{T}}この形式は、メソッドシグネチャでよく使われます。
この形式では、変数は外側のものから順に並べます。これは、T{p1, p2, ...}構文を使って型をパラメーター値に「適用」するときに、変数が置き換えられる順序と一致します。
= — Keyword
==は代入演算子です。
- 変数
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)はキーワード引数aの値としてbを渡します。 - カンマを含む括弧内では、
(a=1,)はNamedTupleを構築します。
Examples
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
?: — Keyword
a ? b : c条件式の短縮形。「aならbを評価し、そうでなければcを評価する」と読む。ternary operatorとも呼ばれる。
この構文はif a; b else c endと同等だが、bやcの評価によって生じる副作用よりも、大きな式の一部として使われるbまたはcの値を強調したい場合によく使われる。
詳しくは、マニュアルのcontrol flowの節を参照。
Examples
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".= — Keyword
.=ブロードキャスト代入を実行します。右辺の引数はbroadcastと同様に展開され、左辺の引数にインプレースで代入されます。同じ式内の他のドット演算子と融合します。つまり、代入式全体が単一のループに変換されます。
A .= Bはbroadcast!(identity, A, B)に似ています。
Examples
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. — Keyword
.ドット演算子は、オブジェクトのフィールドやプロパティへのアクセス、およびモジュール内で定義された変数へのアクセスに使用します。
一般に、a.b は getproperty(a, :b) を呼び出します(getproperty を参照)。
Examples
julia> z = 1 + 2im; z.im
2
julia> Iterators.product
product (generic function with 1 method)-> — Keyword
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 のマニュアルの節を参照してください。
Base.:(:) — Function
:expr式exprをクォートし、exprの抽象構文木(AST)を返します。ASTの型はExpr、Symbol、またはリテラル値です。構文:identifierは、Symbolと評価されます。
関連項目:Expr、Symbol、Meta.parse
Examples
julia> expr = :(a = b + 2*x)
:(a = b + 2x)
julia> sym = :some_identifier
:some_identifier
julia> value = :0xff
0xff
julia> typeof((expr, sym, value))
Tuple{Expr, Symbol, UInt8}:: — Keyword
:::: 演算子は、値が指定された型であることを表明するか、ローカル変数または関数の戻り値が常に指定された型であることを宣言します。
expression::T が与えられると、まず expression が評価されます。その結果が T 型であれば、その値がそのまま返されます。そうでなければ、TypeError がスローされます。
ローカルスコープでは、構文 local x::T または x::T = expression によって、ローカル変数 x が常に T 型であることを宣言します。この変数に値を代入すると、その値は convert を呼び出して T 型に変換されます。
メソッド宣言では、構文 function f(x)::T によって、メソッドが返す値はすべて T 型に変換されます。
Type Declarations に関するマニュアルの節を参照してください。
Examples
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[] — Keyword
[]角括弧は、indexing(getindex)、indexed assignment(setindex!)、array literals(Base.vect)、array concatenation(vcat、hcat、hvcat、hvncat)、およびarray comprehensions(collect)に使用されます。
Standard Modules
Base Submodules
Base.Broadcast — Module
Base.Broadcastブロードキャストの実装を含むモジュール。
Base.Docs — Module
DocsDocs モジュールは、Julia オブジェクトのドキュメントメタデータを設定および取得するための @doc マクロを提供します。
詳しくは、documentation のマニュアルをご覧ください。
Base.Iterators — Module
イテレーターの操作方法。
Base.StackTraces — Module
スタックトレースの収集・操作に使うツール。主にエラーの構築に使用します。
Base.Threads — Module
マルチスレッド対応。
All Objects
Core.:(===) — Function
===(x,y)::Bool
≡(x,y)::Boolxとyが、どのプログラムからも区別できないという意味で同一かどうかを判定します。まず、xとyの型を比較します。型が同一であれば、可変オブジェクトはメモリ上のアドレスで比較し、不変オブジェクト(数値など)はビット単位の内容で比較します。この関数は「egal」と呼ばれることもあります。常にBool値を返します。
Examples
julia> a = [1, 2]; b = [1, 2];
julia> a == b
true
julia> a === b
false
julia> a === a
trueBase.isequal — Function
isequal(x)引数を isequal を使って x と比較する関数を作成します。つまり、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))です。
Implementation
isequalのデフォルト実装は==を呼び出すため、浮動小数点値を含まない型では、通常==を定義するだけで十分です。
isequalは、ハッシュテーブル(Dict)で使われる比較関数です。isequal(x,y)ならば、hash(x) == hash(y)でなければなりません。
通常、カスタムの==またはisequalメソッドが定義されている型では、それに対応するhashメソッドも実装する必要があります(逆も同様です)。コレクションでは通常、すべての要素に対して再帰的にisequalを呼び出すことで、isequalを実装します。
さらに、isequalはislessと連携し、固定された全順序を定義します。このとき、isequal(x, y)、isless(x, y)、isless(y, x)のうち、trueであるものは必ず1つだけで、残り2つはfalseでなければなりません。
スカラー型では一般に、isequalを==とは別に実装する必要はありません。ただし、浮動小数点数を表す型で、汎用フォールバック実装(isnan、signbit、==に基づくもの)より効率的な実装が可能な場合は除きます。
Examples
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)
trueBase.isless — Function
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! が使用するデフォルトの比較です。
Implementation
全順序を持つ非数値型では、この関数を実装する必要があります。数値型では、NaN のような特殊値を持つ場合にのみ実装が必要です。半順序を持つ型では、< を実装してください。ソートや関連する関数で使用できる別の順序付け方法の定義については、Alternate Orderings のドキュメントを参照してください。
Examples
julia> isless(1, 3)
true
julia> isless("Red", "Blue")
falseBase.ispositive — Function
ispositive(x)x > 0かどうかをテストします。isnegativeも参照してください。
Examples
julia> ispositive(-4.0)
false
julia> ispositive(99)
true
julia> ispositive(0.0)
falseBase.isnegative — Function
isnegative(x)x < 0かどうかをテストします。ispositiveも参照してください。
Examples
julia> isnegative(-4.0)
true
julia> isnegative(99)
false
julia> isnegative(-0.0)
falseBase.isunordered — Function
isunordered(x)xが<に従って順序付けできない値(NaNやmissingなど)の場合、trueを返します。
この述語でtrueと評価される値でも、islessなど、別の順序関係では順序付けできる場合があります。
Base.ifelse — Function
ifelse(condition::Bool, x, y)x を返します。ただし、condition が true の場合に限ります。それ以外の場合は、y を返します。これは ? や if とは異なり、通常の関数であるため、すべての引数が先に評価されます。場合によっては、if 文の代わりに ifelse を使うと、生成されるコードの分岐をなくし、タイトなループでのパフォーマンスを向上させられます。
Examples
julia> ifelse(1 > 2, 1, 2)
2Core.typeassert — Function
typeassert(x, type)TypeErrorをスローします。ただし、x isa typeの場合を除きます。この関数は、x::typeという構文で呼び出します。
Examples
julia> typeassert(2.5, Int)
ERROR: TypeError: in typeassert, expected Int64, got a value of type Float64
Stacktrace:
[...]Core.typeof — Function
typeof(x)xの具象型を取得します。
eltypeを参照してください。
Examples
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})Core.tuple — Function
tuple(xs...)与えられたオブジェクトからタプルを構築します。
関連項目: Tuple、ntuple、NamedTuple。
Examples
julia> tuple(1, 'b', pi)
(1, 'b', π)
julia> ans === (1, 'b', π)
true
julia> Tuple(Real[1, 2, pi]) # takes a collection
(1, 2, π)Base.ntuple — Function
ntuple(f, ::Val{N})長さがNのタプルを作成し、各要素をf(i)として計算します。ここで、iはその要素のインデックスです。Val(N)引数を渡すことで、長さを整数で指定するバージョンよりも、このバージョンのntupleのほうが効率的なコードを生成できる場合があります。ただし、Nをコンパイル時に決定できない場合は、ntuple(f, Val(N))よりもntuple(f, N)が適しています。
Examples
julia> ntuple(i -> 2*i, Val(4))
(2, 4, 6, 8)ntuple(f, n::Integer)長さが n のタプルを作成します。各要素は、要素のインデックスを i として、f(i) と計算します。
Examples
julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)Base.objectid — Function
objectid(x)::UIntオブジェクトの同一性に基づいて、xのハッシュ値を取得します。この値は一意ではなく、Juliaのプロセスやバージョンが異なると安定しません。
x === yの場合はobjectid(x) == objectid(y)となり、通常はx !== yの場合はobjectid(x) != objectid(y)となります。
Base.hash — Function
hash(x[, h::UInt])::UIntisequal(x,y)がisequal(hash(x), hash(y))を意味するような整数ハッシュコードを計算します。省略可能な第2引数hは、結果と混合する別のハッシュコードです。
新しい型では、通常、内容のハッシュを互いに(またhとも)混合するために、2引数形式を実装し、2引数のhashメソッドを再帰的に呼び出します。通常、hashを実装する型は、上記の性質を保証するために、独自の==(したがってisequal)も実装する必要があります。
ハッシュ値は、新しいJuliaプロセスを開始すると変わることがあります。
2引数形式を実装する際、第2引数hに、h = UInt(0)のようなデフォルト値を指定してはいけません。これにより、フォールバック(Note on Optional and keyword Argumentsを参照)よりも具体的な1引数メソッドが暗黙的に作成されますが、シードが誤っている可能性があり、ハッシュの不整合を引き起こすためです。
julia> a = hash(10)
0x759d18cc5346a65f
julia> hash(10, a) # only use the output of another hash function as the second argument
0x03158cd61b1b0bd1Base.finalizer — Function
finalizer(f, x)f(x) を、x へのプログラムからアクセス可能な参照がなくなったときに呼び出されるよう登録し、x を返します。x の型は mutable struct でなければなりません。そうでない場合、この関数は例外をスローします。
f はタスク切り替えを引き起こしてはなりません。そのため、println など、ほとんどの I/O 操作は実行できません。デバッグ時には、@async マクロ(コンテキスト切り替えをファイナライザーの外側に遅延させるため)や、ccall を使って C の I/O 関数を直接呼び出すと役立つ場合があります。
f の実行時の world age は保証されていないことに注意してください。ファイナライザーが登録された時点の world age、またはそれ以降の任意の world age で呼び出される可能性があります。
Examples
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
endBase.finalize — Function
finalize(x)オブジェクト x に登録されているファイナライザーを直ちに実行します。
Base.deepcopy — Function
deepcopy(x)xのディープコピーを作成します。すべての要素が再帰的にコピーされ、完全に独立したオブジェクトになります。たとえば、配列をディープコピーすると、配列に含まれるすべてのオブジェクトもディープコピーされ、元の配列と一貫した参照関係を持つ新しい配列が作成されます(たとえば、元の配列の最初の2つの要素が同じオブジェクトであれば、新しい配列でも最初の2つの要素は同じdeepcopyされたオブジェクトを参照します)。オブジェクトに対してdeepcopyを呼び出すと、通常はそのオブジェクトをシリアライズしてからデシリアライズした場合と同じ結果になります。
通常は必要ありませんが、ユーザー定義型では、関数deepcopy_internal(x::T, dict::IdDict)の特殊化版(通常は使用すべきではありません)を定義することで、デフォルトのdeepcopyの動作をオーバーライドできます。ここで、Tは特殊化の対象となる型で、dictは再帰処理中にコピー済みのオブジェクトを記録します。定義内では、deepcopyの代わりにdeepcopy_internalを使用し、戻り値を返す前にdict変数を適切に更新してください。
Base.getproperty — Function
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) を呼び出します。
Examples
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
1getproperty のオーバーロードは、必要な場合に限るべきです。構文 obj.f の動作が通常と異なると、混乱を招く可能性があるためです。また、メソッドを使うほうが望ましい場合も多いことに注意してください。詳しくは、スタイルガイドのドキュメント Prefer exported methods over direct field access も参照してください。
getfield、propertynames、setproperty! も参照してください。
Base.setproperty! — Function
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 も参照してください。
Base.replaceproperty! — Function
replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)egal に従って、x.f の値が expected の場合に、desired に置き換える比較交換操作を実行します。関数呼び出し形式の代わりに、@atomicreplace x.f expected => desired という構文も使用できます。
Base.swapproperty! — Function
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! も参照してください。
Base.modifyproperty! — Function
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) を返します。第1引数には getproperty 式を指定する必要があり、その式はアトミックに変更されます。
op(getproperty(x, f), v) の呼び出しは、デフォルトでオブジェクト x のフィールド f に格納できる値を返す必要があります。特に、setproperty! のデフォルトの動作とは異なり、convert 関数は自動的には呼び出されません。
modifyfield! および setproperty! も参照してください。
Base.setpropertyonce! — Function
setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)x.fに対して比較交換操作を行い、未設定の場合はvalueに設定します。関数呼び出し形式の代わりに、構文@atomiconce x.f = valueを使用できます。
Base.propertynames — Function
propertynames(x, private=false)オブジェクト x のプロパティ(x.property)をタプルまたはベクトルとして取得します。通常、これは fieldnames(typeof(x)) と同じです。ただし、getproperty をオーバーロードする型では、その型のインスタンスのプロパティを取得できるよう、一般に propertynames もオーバーロードする必要があります。
propertynames(x) が返すのは、x のドキュメント化されたインターフェースに含まれる「パブリック」なプロパティ名だけの場合があります。内部使用を目的とした「プライベート」なプロパティ名も返すには、2 番目の省略可能な引数に true を渡します。REPL で x. のタブ補完に表示されるのは、private=false プロパティだけです。
関連項目: hasproperty、hasfield。
Base.hasproperty — Function
Core.getfield — Function
getfield(value, name::Symbol, [order::Symbol], [boundscheck::Bool=true])
getfield(value, i::Int, [order::Symbol], [boundscheck::Bool=true])複合型valueから、名前または位置を指定してフィールドを取り出します。
この操作では、順序を指定することもできます。フィールドが@atomicとして宣言されている場合、その指定は、その場所への書き込みと互換性があることが強く推奨されます。それ以外の場合、@atomicとして宣言されていないなら、このパラメーターを指定する際は:not_atomicでなければなりません。
境界チェックは無効にできます。その場合、iが範囲外であれば、この関数の動作は未定義です。
関連項目:getpropertyおよびfieldnames。
Examples
julia> a = 1//2
1//2
julia> getfield(a, :num)
1
julia> a.num
1
julia> getfield(a, 1)
1Core.setfield! — Function
setfield!(value, name::Symbol, x, [order::Symbol])
setfield!(value, i::Int, x, [order::Symbol])複合型のvalueにある名前付きフィールドに、xを代入します。valueは可変でなければならず、xはfieldtype(typeof(value), name)のサブタイプでなければなりません。また、この操作では順序を指定できます。フィールドが@atomicとして宣言されている場合、この指定は必須です。それ以外の場合、@atomicとして宣言されていなければ、順序を指定する際には:not_atomicでなければなりません。setproperty!も参照してください。
Examples
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 changedCore.modifyfield! — Function
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ハードウェアが対応している場合(アトミックなインクリメントなど)は、適切なハードウェア命令に最適化されることがあります。対応していない場合は、ループを使用します。
Core.replacefield! — Function
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)ハードウェアが対応している場合は、適切なハードウェア命令に最適化されます。対応していない場合は、ループを使用します。
Core.swapfield! — Function
swapfield!(value, name::Symbol, x, [order::Symbol])
swapfield!(value, i::Int, x, [order::Symbol])フィールドの取得と設定を同時に行う操作をアトミックに実行します。
y = getfield(value, name)
setfield!(value, name, x)
return yCore.setfieldonce! — Function
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 okCore.isdefined — Function
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 も参照してください。
Examples
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)
falseCore.isdefinedglobal — Function
isdefinedglobal(m::Module, s::Symbol, [allow_import::Bool=true, [order::Symbol=:unordered]])モジュール m 内で(現在のワールドエイジにおいて)グローバル変数 s が定義されているかどうかを判定します。グローバル変数から値を読み取ることができ、そのアクセスで例外がスローされない場合に限り、その変数は定義されているとみなされます。これには、定数と、値が設定されているグローバル変数の両方が含まれます。
allow_import が false の場合、グローバル変数は m 内で定義されている必要があり、別のモジュールからインポートすることはできません。
関連項目: @isdefined。
Examples
julia> isdefinedglobal(Base, :sum)
true
julia> isdefinedglobal(Base, :NonExistentMethod)
false
julia> isdefinedglobal(Base, :sum, false)
true
julia> isdefinedglobal(Main, :sum, false)
falseBase.@isdefined — Macro
@isdefined(s)::Bool変数 s が現在のスコープで定義されているかどうかを判定します。
フィールドのプロパティについては isdefined、配列のインデックスについては isassigned、その他のマッピングについては haskey も参照してください。
Examples
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
trueBase.convert — Function
convert(T, x)xをT型の値に変換します。
TがInteger型の場合、xをTで表現できないと、InexactErrorが発生します。たとえば、xが整数値でない場合や、Tでサポートされる範囲外の場合です。
Examples
julia> convert(Int, 3.0)
3
julia> convert(Int, 3.5)
ERROR: InexactError: Int64(3.5)
Stacktrace:
[...]TがAbstractFloat型の場合、xに最も近い、Tで表現可能な値を返します。最近傍を判定する際、Infはfloatmax(T)より1 ulp大きい値として扱われます。
julia> x = 1/3
0.3333333333333333
julia> convert(Float32, x)
0.33333334f0
julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125Tがコレクション型で、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。
Base.promote — Function
promote(xs...)すべての引数を共通の型に変換し、タプルとして返します。変換可能な引数がない場合は、エラーが発生します。
関連項目: promote_type、promote_rule。
Examples
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)
AnyBase.oftype — Function
oftype(x, y)yをxの型に変換します。つまり、convert(typeof(x), y)です。
Examples
julia> x = 4;
julia> y = 3.;
julia> oftype(x, y)
3
julia> oftype(y, x)
4.0Base.widen — Function
widen(x)x が型の場合、算術演算 + および - でオーバーフローや精度の損失が発生しないことが、x 型で表現可能な値のあらゆる組み合わせについて保証される「より大きな」型を返します。
128 ビット未満の固定サイズ整数型の場合、widen はビット数が 2 倍の型を返します。
x が値の場合は、widen(typeof(x)) に変換されます。
Examples
julia> widen(Int32)
Int64
julia> widen(1.5f0)
1.5Base.identity — Function
identity(x)恒等関数。引数をそのまま返します。
関連項目: one、oneunit、および LinearAlgebra の I。
Examples
julia> identity("Well, what did you expect?")
"Well, what did you expect?"Core.WeakRef — Type
WeakRef(x)w = WeakRef(x) は、Julia の値 x への weak reference を構築します。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)Properties of Types
Type relations
Core.DataType — Type
DataType <: Type{T}DataTypeは、名前と明示的に宣言されたスーパータイプを持ち、必要に応じてパラメーターも持つ、明示的に宣言された型を表します。システム内のすべての具体的な値は、いずれかのDataTypeのインスタンスです。
Examples
julia> typeof(Real)
DataType
julia> typeof(Int)
DataType
julia> struct Point
x::Int
y
end
julia> typeof(Point)
DataTypeCore.:<: — Function
<:(T1, T2)::Bool2つの型の間に定義される部分型関係。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 も参照してください。
Examples
julia> Float64 <: AbstractFloat
true
julia> Vector{Int} <: AbstractArray
true
julia> Matrix{Float64} <: Matrix{AbstractFloat} # `Matrix` is invariant
false
julia> Tuple{Float64} <: Tuple{AbstractFloat} # `Tuple` is covariant
true
julia> Union{} <: Int # The bottom type, `Union{}`, subtypes each type.
true
julia> Union{} <: Float32 <: AbstractFloat <: Real <: Number <: Any # Operator chaining
trueキーワード <: には、同じ部分型関係を表す構文上の用法がほかにもいくつかあります。ただし、これらの用法では演算子は実行されず、Bool も返されません。
where文で、UnionAll型のパラメーターの下限と上限を指定する。- メソッドの(静的)パラメーターの下限と上限を指定する。Parametric Methods を参照。
- 新しい型の宣言時に部分型関係を定義する。
structとabstract typeを参照。
Base.typejoin — Function
typejoin(T, S, ...)T と S の最も近い共通祖先、つまり両方が継承する型のうち最も限定的なものを返します。追加の可変長引数がある場合は、再帰的に処理します。
Examples
julia> typejoin(Int, Float64)
Real
julia> typejoin(Int, Float64, ComplexF32)
NumberBase.typeintersect — Function
typeintersect(T::Type, S::Type)TとSの共通部分を含む型を計算します。通常は、そのような型のうち最小のもの、またはそれに近い型になります。
次の場合は、特別に正確な動作が保証されます。T <: S、typeintersect(S, T) == T == typeintersect(T, S)。
Base.promote_type — Function
promote_type(type1, type2, ...)昇格とは、異なる型の値を、共通の単一の型に変換することです。promote_type は、演算子(通常は数学演算子)に異なる型の引数が渡されたときの、Julia におけるデフォルトの昇格動作を表します。promote_type は、型を過度に広げることなく、どちらの入力型の値もおおむね表現できる型を返そうとします。多少の精度損失は許容されます。たとえば、厳密にはすべての Int64 の値を Float64 の値として正確に表現できないにもかかわらず、promote_type(Int64, Float64) は Float64 を返します。
関連項目: promote、promote_typejoin、promote_rule。
Examples
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 をオーバーロードしてください。promote_type は、型を判定するために内部で promote_rule を呼び出します。promote_type を直接オーバーロードすると、曖昧性エラーが発生することがあります。
Base.promote_rule — Function
promote_rule(type1, type2)promote に型 type1 および type2 の値が渡されたときに、どの型を使用するかを指定します。この関数を直接呼び出すべきではありません。新しい型を追加する際は、必要に応じてこの関数に定義を追加してください。
Base.promote_typejoin — Function
promote_typejoin(T, S)TとSの両方を含む型を計算します。これは、両方の型の親型、または適切な場合はUnionになります。該当しない場合はtypejoinにフォールバックします。
代わりにpromote、promote_typeを参照してください。
Examples
julia> Base.promote_typejoin(Int, Float64)
Real
julia> Base.promote_type(Int, Float64)
Float64Base.iskindtype — Function
Base.iskindtype(T)Tがkind、つまりJuliaの型の型であるかどうかを判定します。DataType、Union、UnionAll、またはCore.TypeofBottomです。
型はJuliaの値であるため、すべてのkindはconcreteです。
Base.isdispatchtuple — Function
isdispatchtuple(T)型 T が、ディスパッチで型シグネチャとして使われる可能性のある Tuple かどうかを判定します。これに該当するには、タプル型の各要素が次のいずれかでなければなりません。
ディスパッチタプルには要素を持つ部分型がないため、メソッドディスパッチにおいて重要です。
たとえば、Tuple{Int, DataType} は具象型ですが、Tuple{Int, Type{Bool}} は要素を持つ部分型なので、ディスパッチタプルではありません。
Tuple{Tuple{DataType}} はディスパッチタプルです。Tuple{DataType} は具象型であり、種類ではないためです。部分型 Tuple{Tuple{Type{Int}}} は要素を持ちません。
T が型でない場合は、false を返します。
Examples
julia> isdispatchtuple(Int)
false
julia> isdispatchtuple(Tuple{Int})
true
julia> isdispatchtuple(Tuple{Number})
false
julia> isdispatchtuple(Tuple{DataType})
false
julia> isdispatchtuple(Tuple{Type{Int}})
true
julia> isdispatchtuple(Tuple{Type})
falseDeclared structure
Base.ismutable — Function
ismutable(v)::Bool値 v が可変である場合に限り、true を返します。不変性については Mutable Composite Types を参照してください。この関数は値を対象とするため、DataType を渡すと、その型の値は可変であると判定されます。
isbits、isstructtype も参照してください。
Examples
julia> ismutable(1)
false
julia> ismutable([1,2])
trueBase.isimmutable — Function
isimmutable(v) -> Boolisimmutable(v) は将来のリリースで !ismutable(v) に置き換えられるため、代わりに !ismutable(v) を使用することを検討してください。(Julia 1.5 以降)
値 v が不変の場合に限り、true を返します。不変性については Mutable Composite Types を参照してください。この関数は値を対象とするため、型を渡すと、DataType の値は可変であると判定されます。
Examples
julia> isimmutable(1)
true
julia> isimmutable([1,2])
falseBase.ismutabletype — Function
ismutabletype(T)::BoolT 型が可変型として宣言されているか(つまり、mutable struct キーワードを使って宣言されているか)を判定します。T が型でない場合は、false を返します。
Base.isabstracttype — Function
isabstracttype(T)型 T が抽象型として宣言されているか(つまり、abstract type 構文を使用しているか)を判定します。T が型でない場合は、false を返します。
関連項目: isconcretetype。
Examples
julia> isabstracttype(AbstractArray)
true
julia> isabstracttype(Vector)
falseBase.isprimitivetype — Function
isprimitivetype(T)::Bool型 T がプリミティブ型(つまり、primitive type 構文を使って宣言された型)かどうかを判定します。T が型でない場合は、false を返します。
Base.issingletontype — Function
Base.issingletontype(T)型 T が、唯一のインスタンスだけを持つかどうかを判定します。たとえば、他のシングルトン値だけをフィールドに持つ構造体型が該当します。T が具象型でない場合は、false を返します。
Base.isstructtype — Function
isstructtype(T)::Bool型 T が構造体型(つまり、struct または mutable struct キーワードを使って宣言された型)かどうかを判定します。T が型でない場合は、false を返します。
Base.nameof — Method
nameof(t::DataType)::Symbol(UnionAllで囲まれている可能性のある)DataTypeの名前を、親モジュールを含めずにシンボルとして取得します。
Examples
julia> module Foo
struct S{T}
end
end
Foo
julia> nameof(Foo.S{T} where T)
:SBase.fieldnames — Function
fieldnames(x::DataType)DataType のフィールド名をタプルとして取得します。
各名前は Symbol です。ただし x <: Tuple の場合は、各名前(実際にはフィールドのインデックス)は Int になります。
関連項目: propertynames、hasfield。
Examples
julia> fieldnames(Rational)
(:num, :den)
julia> fieldnames(typeof(1+im))
(:re, :im)
julia> fieldnames(Tuple{String,Int})
(1, 2)Base.fieldname — Function
fieldname(x::DataType, i::Integer)i の DataType のフィールド名を取得します。
戻り値の型は Symbol です。ただし、x <: Tuple の場合はフィールドのインデックスが返され、その型は Int です。
Examples
julia> fieldname(Rational, 1)
:num
julia> fieldname(Rational, 2)
:den
julia> fieldname(Tuple{String,Int}, 2)
2Base.fieldindex — Function
fieldindex(T, name::Symbol, err:Bool=true)名前付きフィールドのインデックスを取得します。フィールドが存在しない場合、err==true ならエラーをスローし、err==false なら 0 を返します。
Examples
julia> struct Foo
x::Int64
y::String
end
julia> fieldindex(Foo, :y)
2
julia> fieldindex(Foo, :z)
ERROR: FieldError: type Foo has no field `z`, available fields: `x`, `y`
Stacktrace:
[...]
julia> fieldindex(Foo, :z, false)
0Core.fieldtype — Function
fieldtype(T, name::Symbol | index::Int)複合 DataType T のフィールド(名前またはインデックスで指定)の宣言型を取得します。
Examples
julia> struct Foo
x::Int64
y::String
end
julia> fieldtype(Foo, :x)
Int64
julia> fieldtype(Foo, 2)
StringBase.fieldtypes — Function
fieldtypes(T::Type)複合型 DataType T のすべてのフィールドの宣言型をタプルとして返します。
Examples
julia> struct Foo
x::Int64
y::String
end
julia> fieldtypes(Foo)
(Int64, String)Base.fieldcount — Function
fieldcount(t::Type)指定された型のインスタンスが持つフィールド数を取得します。型が抽象的すぎてフィールド数を特定できない場合は、エラーがスローされます。
Base.hasfield — Function
hasfield(T::Type, name::Symbol)T が name を自身のフィールドの1つとして持つかどうかを示す真偽値を返します。
関連項目: fieldnames、fieldcount、hasproperty。
Examples
julia> struct Foo
bar::Int
end
julia> hasfield(Foo, :bar)
true
julia> hasfield(Foo, :x)
falseCore.nfields — Function
nfields(x)::Int指定されたオブジェクトのフィールド数を取得します。
Examples
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 はフィールドを2つ持つ Rational です。b は Int であり、フィールドをまったく持たないプリミティブなビット型です。ex はフィールドを1つ持つ ErrorException です。
Base.isconst — Function
isconst(t::DataType, s::Union{Int,Symbol})::Bool指定された型 t において、フィールド s が const かどうかを判定します。ここでいう const とは、等しいオブジェクト間でそのフィールドを読み取った結果が一致することを意味します。特に、範囲外のフィールドもこの定義では const とみなされる点に注意してください(常に例外をスローするためです)。
isconst(m::Module, s::Symbol)::Bool
isconst(g::GlobalRef)::Bool指定されたモジュール m において、グローバル変数が const かどうかを判定します。定数として宣言されている場合と、定数束縛からインポートされている場合のどちらも該当します。定数であるかどうかは特定のワールドエイジに依存するため、ワールドエイジが更新された後もこの関数の結果が有効だとは限りません。
Base.isfieldatomic — Function
isfieldatomic(t::DataType, s::Union{Int,Symbol})::Bool指定された型 t にフィールド s が @atomic として宣言されているかどうかを判定します。
Memory layout
Base.sizeof — Method
sizeof(T::DataType)
sizeof(obj)指定された DataType T に標準的なバイナリ表現がある場合、そのサイズをバイト単位で返します。また、オブジェクト obj が DataType でない場合は、そのオブジェクトのサイズをバイト単位で返します。
Base.summarysize も参照してください。
Examples
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) # not the sum of `sizeof` of fields due to padding
16
julia> sizeof(Int64) + sizeof(Bool) # different from above
9DataType T のサイズが定まっていない場合は、エラーがスローされます。
julia> sizeof(AbstractArray)
ERROR: Abstract type AbstractArray does not have a definite size.
Stacktrace:
[...]Base.isconcretetype — Function
isconcretetype(T)型 T が具象型かどうか、つまり直接インスタンス(x を満たす値 typeof(x) === T)を持ち得るかどうかを判定します。これは isabstracttype(T) の否定ではないことに注意してください。T が型でない場合は、false を返します。
T は、typeof が返す型と完全に一致していなければなりません。型 U が存在し、T == U、isconcretetype(T) である一方、!isconcretetype(U) ではない場合があります。
関連項目: isbits、isabstracttype、issingletontype。
Examples
julia> isconcretetype(Complex)
false
julia> isconcretetype(Complex{Float32})
true
julia> isconcretetype(Vector)
false
julia> isconcretetype(Vector{Complex})
true
julia> isconcretetype(Vector{Complex{Float32}})
true
julia> isconcretetype(Union{})
false
julia> isconcretetype(Union{Int,String})
false
julia> isconcretetype(Tuple{T} where T<:Int)
falseBase.isbits — Function
isbits(x)true を返すのは、x が isbitstype 型のインスタンスである場合です。
Base.isbitstype — Function
isbitstype(T)trueを返します。ただし、Tが「プレーンデータ」型、つまり不変で、他の値への参照を含まず、primitive型とその他のisbitstype型のみを含む場合に限ります。典型的な例は、UInt8、Float64、Complex{Float64}などの数値型です。この型のカテゴリが重要なのは、型パラメーターとして有効であり、isdefined / isassignedの状態を追跡しない場合があり、Cと互換性のある定義済みのメモリレイアウトを持つためです。Tが型でない場合は、falseを返します。
関連項目: isbits、isprimitivetype、ismutable。
Examples
julia> isbitstype(Complex{Float64})
true
julia> isbitstype(Complex)
falseBase.fieldoffset — Function
fieldoffset(type, name::Symbol | i::Integer)型の先頭からの、フィールド(名前またはインデックスで指定)のバイトオフセット。
Examples
julia> struct Foo
x::Int64
y::String
end
julia> fieldoffset(Foo, 2)
0x0000000000000008
julia> fieldoffset(Foo, :x)
0x0000000000000000これを使って、構造体に関する情報をまとめられます。
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 — Function
Base.datatype_alignment(dt::DataType)::Intこの型のインスタンスに必要なメモリ割り当ての最小アラインメント。任意のisconcretetypeに対して呼び出せますが、Memoryの場合はオブジェクト全体ではなく、要素のアラインメントが返されます。
Base.datatype_haspadding — Function
Base.datatype_haspadding(dt::DataType)::Boolこの型のインスタンスのフィールドが、メモリ上で隙間なく配置されているかどうかを返します。ここでいう隙間とは、インスタンス自体の意味上の値に影響しないビットを指します。任意のisconcretetypeに対して呼び出せます。
Base.datatype_pointerfree — Function
Base.datatype_pointerfree(dt::DataType)::Boolこの型のインスタンスが、GC 管理メモリへの参照を含む可能性があるかどうかを返します。任意の isconcretetype に対して呼び出せます。
Special values
Base.typemin — Function
typemin(T)指定された(実数の)数値 DataType で表現可能な最小値 T。
関連項目: floatmin、maxintfloat、typemax、eps。
Examples
julia> typemin(Int8)
-128
julia> typemin(UInt32)
0x00000000
julia> typemin(Float16)
-Inf16
julia> typemin(Float32)
-Inf32
julia> floatmin(Float32) # smallest positive finite Float32 floating point number
1.1754944f-38
julia> nextfloat(-Inf32) == -floatmax(Float32) # equivalent ways of getting the lowest finite Float32 floating point number
trueBase.typemax — Function
typemax(T)指定された(実数)数値型で表現できる最大値 DataType。
関連項目: floatmax, maxintfloat, typemin, eps。
Examples
julia> typemax(Int8)
127
julia> typemax(UInt32)
0xffffffff
julia> typemax(Float64)
Inf
julia> typemax(Float32)
Inf32
julia> floatmax(Float32) # largest positive finite Float32 floating point number
3.4028235f38Base.floatmin — Function
floatmin(T = Float64)浮動小数点型 T で表現可能な、最小の正規化数を返します。
関連項目: typemin、maxintfloat、floatmax、eps。
Examples
julia> floatmin(Float16)
Float16(6.104e-5)
julia> floatmin(Float32)
1.1754944f-38
julia> floatmin()
2.2250738585072014e-308Base.floatmax — Function
floatmax(T = Float64)浮動小数点型 T で表現可能な最大の有限数を返します。
関連項目: typemax、maxintfloat、floatmin、eps。
Examples
julia> floatmax(Float16)
Float16(6.55e4)
julia> floatmax(Float32)
3.4028235f38
julia> floatmax()
1.7976931348623157e308
julia> typemax(Float64)
InfBase.maxintfloat — Function
maxintfloat(T, S)指定された浮動小数点型 T で表現でき、かつ整数型 S で表現可能な最大の整数を超えない、連続する整数のうち最大のもの。言い換えると、maxintfloat(T) と typemax(S) の最小値です。
maxintfloat(T=Float64)指定された浮動小数点型 T(デフォルトは Float64)で正確に表現できる、連続する整数値の浮動小数点数のうち最大のもの。
つまり、maxintfloat は、n+1 が型 T で正確に表現できないような、最小の正の整数値の浮動小数点数 n を返します。
Integer 型の値が必要な場合は、Integer(maxintfloat(T)) を使用してください。
Base.eps — Method
eps(::Type{T}) where T<:AbstractFloat
eps()浮動小数点型 T(デフォルトでは T = Float64)の機械イプシロンを返します。これは、typeof(one(T)) で表現可能な 1 と、その次に大きい値との間隔として定義され、eps(one(T)) と等価です。(eps(T) は T の相対誤差の上限なので、one と同様に「無次元」の量です。)
Examples
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$(任意の実数など)に最も近い浮動小数点値が $ext{fl}(x)$ であるとすると、オーバーフローの場合を除き、$ext{fl}(x)$ は $|x - ext{fl}(x)| ≤ ext{eps}(x)/2$ を満たします。これにより、eps の定義を複素数にも拡張でき、その場合は $ext{fl}(a + ib) = ext{fl}(a) + i ext{fl}(b)$ となります。
Base.eps — Method
eps(x::AbstractFloat)x の 最下位桁の単位(ulp)を返します。これは、x における、隣り合う表現可能な浮動小数点数の間の距離です。通常、x の両側で距離が異なる場合は、大きい方を採用します。つまり、
eps(x) == max(x-prevfloat(x), nextfloat(x)-x)この規則の例外は、最小および最大の有限値(たとえば、nextfloat(-Inf) と prevfloat(Inf)(Float64 の場合))です。これらの値では、小さい方の値に丸められます。
この動作の根拠は、eps が浮動小数点の丸め誤差の上限となることです。デフォルトの丸めモードである RoundNearest では、$y$ が実数で、$x$ が $y$ に最も近い浮動小数点数であるとき、
\[|y-x| \leq \operatorname{eps}(x)/2.\]
関連項目:nextfloat、issubnormal、floatmax。
Examples
julia> eps(1.0)
2.220446049250313e-16
julia> eps(prevfloat(2.0))
2.220446049250313e-16
julia> eps(2.0)
4.440892098500626e-16
julia> x = prevfloat(Inf) # largest finite Float64
1.7976931348623157e308
julia> x + eps(x)/2 # rounds up
Inf
julia> x + prevfloat(eps(x)/2) # rounds down
1.7976931348623157e308Base.instances — Function
instances(T::Type)該当する場合は、指定された型のすべてのインスタンスを返します。主に列挙型で使用されます(@enumを参照)。
Examples
julia> @enum Color red blue green
julia> instances(Color)
(red, blue, green)Special Types
Core.Union — Type
Union{Types...}Union型は抽象型であり、その引数型のいずれかに属するすべてのインスタンスを含みます。つまり、T <: Union{T,S}とS <: Union{T,S}です。
ほかの抽象型と同様、すべての引数が具象型であっても、インスタンス化することはできません。
Examples
julia> IntOrString = Union{Int,AbstractString}
Union{Int64, AbstractString}
julia> 1 isa IntOrString # instance of Int is included in the union
true
julia> "Hello!" isa IntOrString # String is also included
true
julia> 1.0 isa IntOrString # Float64 is not included because it is neither Int nor AbstractString
falseExtended Help
ほとんどのパラメトリック型とは異なり、Union型はパラメーターに関して共変です。たとえば、Union{Real, String}はUnion{Number, AbstractString}のサブタイプです。
空のUnion型であるUnion{}は、Juliaのボトム型です。
Union{} — Keyword
Union{}Union{}は、型の集合が空であるUnionであり、型システムにおける最下位の型です。つまり、各T::Typeについて、Union{} <: Tです。部分型演算子のドキュメントも参照してください: <:。
そのため、Union{}も空/要素を持たない型であり、値を持ちません。つまり、各xについて、isa(x, Union{}) == falseです。
Base.Bottomはその別名として定義されており、Union{}の型はCore.TypeofBottomです。
Examples
julia> isa(nothing, Union{})
false
julia> Union{} <: Int
true
julia> typeof(Union{}) === Core.TypeofBottom
true
julia> isa(Union{}, Union)
falseCore.TypeofBottom — Type
Core.TypeofBottom値 Union{} のみを含むシングルトン型(これは空型を表します)。
Core.UnionAll — Type
UnionAll型パラメーターが取り得るすべての値に対する型の和集合。UnionAllは、一部のパラメーターの値が不明なパラメトリック型を表すために使われます。UnionAll Typesのマニュアルの節を参照してください。
Examples
julia> typeof(Vector)
UnionAll
julia> typeof(Vector{Int})
DataTypeCore.Tuple — Type
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}は抽象型とみなされ、タプル型が具象型となるのは、その型パラメータが具象型である場合に限られます。タプルにはフィールド名がなく、フィールドにはインデックスでのみアクセスできます。タプル型の型パラメータの数に制限はありません。
Tuple Typesのマニュアルの節を参照してください。
Vararg、NTuple、ntuple、tuple、NamedTupleも参照してください。
Core.NTuple — Type
NTuple{N, T}すべての要素がT型である、長さNのタプルの型を簡潔に表す方法です。
Examples
julia> isa((1, 2, 3, 4, 5, 6), NTuple{6, Int})
truentupleも参照してください。
Core.NamedTuple — Type
NamedTupleNamedTupleは、その名のとおり、名前付きの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を反復すると、名前ではなく値が得られます(下の例を参照)。名前と値のペアを反復するには、pairs関数を使います。
@NamedTupleマクロを使うと、NamedTuple型を簡単に宣言できます。
Examples
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) # the final b overwrites the value from nt1
(a = 1, b = 20, c = 3, d = 4)
julia> (; zip(keys, values)...) # zip yields tuples such as (:a, 1)
(a = 1, b = 2, c = 3)キーワード引数と同様に、識別子やドット式は名前として扱われます。
julia> x = 0
0
julia> t = (; x)
(x = 0,)
julia> (; t.x)
(x = 0,)Base.@NamedTuple — Macro
@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 マクロは、REPL などで 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}Base.@Kwargs — Macro
@Kwargs{key1::Type1, key2::Type2, ...}このマクロを使うと、@NamedTupleと同じ構文で、キーワード引数の型表現を簡単に構築できます。たとえば、func([positional arguments]; kw1=1.0, kw2="2")のような関数呼び出しがある場合、このマクロを使って、キーワード引数の内部的な型表現を@Kwargs{kw1::Float64, kw2::String}として構築できます。このマクロの構文は、スタックトレース表示でキーワードメソッドのシグネチャ型を表示する際に、簡潔になるよう特別に設計されています。
julia> @Kwargs{init::Int} # the internal representation of keyword arguments
Base.Pairs{Symbol, Int64, Nothing, @NamedTuple{init::Int64}}
julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
The function `+` exists, but no method is defined for this combination of argument types.
Closest candidates are:
+(::Any, ::Any, ::Any, ::Any...)
@ Base operators.jl:585
+(::Integer, ::AbstractChar)
@ Base char.jl:247
+(::T, ::Integer) where T<:AbstractChar
@ Base char.jl:237
Stacktrace:
[1] add_sum(x::Char, y::Char)
@ Base ./reduce.jl:24
[2] BottomRF
@ Base ./reduce.jl:86 [inlined]
[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 [inlined]
[5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
@ Base ./reduce.jl:44 [inlined]
[6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
@ Base ./reduce.jl:175 [inlined]
[7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
@ Base ./reduce.jl:307 [inlined]
[8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
@ Base ./reduce.jl:535 [inlined]
[9] sum(a::String; kw::@Kwargs{init::Int64})
@ Base ./reduce.jl:564 [inlined]
[10] top-level scope
@ REPL[12]:1Base.Val — Type
Val(c)実行時データを含まないVal{c}()を返します。このような型を使うと、cを介して関数間で情報を渡せます。この値はisbits値またはSymbolでなければなりません。この構文の目的は、実行時に定数の値を調べることなく、コンパイル時に定数に基づいて直接ディスパッチできるようにすることです。
Examples
julia> f(::Val{true}) = "Good"
f (generic function with 1 method)
julia> f(::Val{false}) = "Bad"
f (generic function with 2 methods)
julia> f(Val(true))
"Good"Core.Vararg — Constant
Vararg{T,N}タプル型 Tuple の最後のパラメーターには、末尾に任意の数の要素が続くことを表す特別な値 Vararg を指定できます。Vararg{T,N} は、型 T の要素がちょうど N 個あることを表します。最後に、Vararg{T} は、型 T の要素が 0 個以上あることを表します。Vararg タプル型は、可変長引数メソッドが受け取る引数を表すために使われます(マニュアルの Varargs Functions の節を参照)。
NTuple も参照してください。
Examples
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)
falseBase.isnothing — Function
Base.notnothing — Function
notnothing(x)x === nothing の場合はエラーをスローし、そうでなければ x を返します。
Base.something — Function
something(x...)引数の中からnothingと等しくない最初の値を返します。該当する値がない場合は、エラーをスローします。Some型の引数はアンラップされます。
coalesce、skipmissing、@somethingも参照してください。
Examples
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 presentBase.@something — Macro
@something(x...)somethingの短絡評価版。
Examples
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
trueBase.Enums.Enum — Type
Enum{T<:Integer}@enumで定義される、すべての列挙型の抽象スーパータイプ。
Base.Enums.@enum — Macro
@enum EnumName[::BaseType] value1[=x] value2[=y]Enum{BaseType} サブタイプを作成し、名前を EnumName とします。列挙メンバーの値には value1 と value2 を指定し、それぞれに x と y を任意で割り当てることができます。EnumName は、通常の値として、ほかの型や列挙メンバーの値と同様に使用できます。たとえば、
Examples
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
endBaseType は、デフォルトでは Int32 となり、Integer のプリミティブサブタイプでなければなりません。メンバー値は、列挙型と BaseType の間で相互に変換できます。read と write は、これらの変換を自動的に行います。列挙型をデフォルト以外の BaseType で作成した場合、Integer(value1) は、型が BaseType の整数 value1 を返します。
列挙型のすべてのインスタンスを列挙するには、instances を使用します。たとえば、
julia> instances(Fruit)
(apple, orange, kiwi)列挙型のインスタンスからシンボルを構築することもできます。
julia> Symbol(apple)
:appleCore.Expr — Type
Expr(head::Symbol, args...)パースされた Julia コード(AST)における複合式を表す型です。各式は、式の種類(関数呼び出し、for ループ、条件文など)を示す head Symbol と、部分式(関数呼び出しの引数など)から構成されます。部分式は、Vector{Any} 型のフィールド args に格納されます。
Metaprogramming に関するマニュアルの章と、開発者向けドキュメント Julia ASTs を参照してください。
Examples
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 cCore.Symbol — Type
Symbolパースされた Julia コード(AST)で識別子を表すために使われるオブジェクトの型です。また、エンティティを識別する名前やラベル(たとえば辞書のキー)として使われることもよくあります。Symbol は、: クォート演算子を使って入力できます。
julia> :name
:name
julia> typeof(:name)
Symbol
julia> x = 42
42
julia> eval(:x)
42Symbol は、コンストラクター Symbol(x...) を呼び出すことで、文字列やその他の値から作成することもできます。
Symbol は不変であり、同じ名前を持つすべての Symbol に対して、実装では同じオブジェクトが再利用されます。
文字列とは異なり、Symbol は「アトミック」または「スカラー」なエンティティであり、文字単位の反復処理には対応していません。
Core.Symbol — Method
Symbol(x...)::Symbol引数の文字列表現を連結して、Symbolを作成します。
Examples
julia> Symbol("my", "name")
:myname
julia> Symbol("day", 4)
:day4Core.Module — Type
ModuleModuleは、独立したグローバル変数のワークスペースです。詳しくは、moduleおよびmanual section about modulesを参照してください。
Module(name::Symbol=:anonymous, std_imports=true, default_names=true)指定した名前のモジュールを返します。baremoduleはModule(:ModuleName, false)に対応します。
名前を一切含まない空のモジュールは、Module(:ModuleName, false, false)で作成できます。このモジュールはBaseもCoreもインポートせず、自身への参照も含みません。
Generic Functions
Core.Function — Type
Functionすべての関数の抽象型。
Examples
julia> isa(+, Function)
true
julia> typeof(sin)
typeof(sin) (singleton type of function sin, subtype of Function)
julia> ans <: Function
trueBase.hasmethod — Function
hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=get_world_counter())::Bool指定された引数型のTupleに一致するメソッドが、world ageの上限をworldとして、指定された汎用関数に存在するかどうかを判定します。
キーワード引数名のタプルkwnamesが指定されている場合、tに一致するfのメソッドが、指定されたキーワード引数名を受け付けるかどうかも確認します。一致するメソッドが、たとえばkwargs...のように可変個数のキーワード引数を受け付ける場合、kwnamesで指定された名前はすべて有効とみなされます。それ以外の場合、指定する名前はメソッドのキーワード引数の部分集合でなければなりません。
関連項目: applicable。
Examples
julia> hasmethod(length, Tuple{Array})
true
julia> f(; oranges=0) = oranges;
julia> hasmethod(f, Tuple{}, (:oranges,))
true
julia> hasmethod(f, Tuple{}, (:apples, :bananas))
false
julia> g(; xs...) = 4;
julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d)) # g accepts arbitrary kwargs
trueCore.applicable — Function
applicable(f, args...)::Bool指定されたジェネリック関数に、指定された引数に適用できるメソッドがあるかどうかを判定します。
hasmethodも参照してください。
Examples
julia> function f(x, y)
x + y
end;
julia> applicable(f, 1)
false
julia> applicable(f, 1, 2)
trueBase.isambiguous — Function
Base.isambiguous(m1, m2; ambiguous_bottom=false)::Bool2つのメソッド m1 と m2 が、ある呼び出しシグネチャに対して曖昧になり得るかどうかを判定します。このテストは、同じ関数に属する他のメソッドも考慮して行われます。単独では m1 と m2 が曖昧になる可能性がありますが、その曖昧さを解消する3つ目のメソッドが定義されている場合、この関数は false を返します。逆に、単独では m1 と m2 の優先順位が決まっていても、3つ目のメソッドをそれらと並べ替えられない場合は、3つが組み合わさることで曖昧さが生じることがあります。
パラメトリック型では、ambiguous_bottom キーワード引数によって、Union{} を型パラメーターの曖昧な交差として扱うかどうかを制御します。true の場合は曖昧と見なされ、false の場合は曖昧とは見なされません。
Examples
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)
falseCore.invoke — Function
invoke(f, argtypes::Type, args...; kwargs...)
invoke(f, argtypes::Method, args...; kwargs...)
invoke(f, argtypes::CodeInstance, args...; kwargs...)指定した引数 args に対し、指定した型 argtypes に一致する、汎用関数 f のメソッドを、キーワード引数 kwargs を渡して呼び出します。引数 args は、指定した型 argtypes に適合している必要があります。つまり、自動的な変換は行われません。このメソッドを使うと、最も具体的に一致するメソッド以外のメソッドを呼び出せます。これは、より一般的な定義の動作を明示的に必要とする場合(多くの場合、同じ関数のより具体的なメソッドの実装の一部として)に便利です。ただし、実行時により多くの処理が必要になるため、invoke は通常の呼び出しによる通常のディスパッチよりも一般に遅く、場合によっては大幅に遅くなります。
自分で実装していない関数に対して invoke を使う場合は注意してください。指定した argtypes にどの定義が使われるかは、その関数が特定の argtypes での呼び出しを公開 API の一部として明示していない限り、実装の詳細です。たとえば、以下の例における f1 から f2 への変更は、通常は互換性があると見なされます。通常の(invoke ではない)呼び出しでは、呼び出し側からその変更が見えないためです。しかし、invoke を使うと、この変更は見えるようになります。
Passing a Method instead of a signature
argtypes 引数には Method を指定できます。その場合、通常のメソッドテーブル検索は完全に省略され、指定したメソッドが直接呼び出されます。この機能が必要になることはまれです。特に、指定した Method は、より具体的なメソッドに置き換えられている、または完全に覆われているなどの理由で、通常のディスパッチ(または通常の invoke)では到達できない場合があります。そのメソッドが通常のメソッドテーブルに含まれている場合、この呼び出しの動作は invoke(f, method.sig, args...) と同様です。
Passing a CodeInstance instead of a signature
argtypes 引数には CodeInstance を指定できます。この場合、メソッド検索と特殊化の両方が省略されます。この呼び出しの意味は、CodeInstance の invoke ポインターを関数ポインターとして呼び出す場合と同様です。CodeInstance を、その親である MethodInstance に一致しない引数で呼び出した場合、または min_world/max_world の範囲に含まれないワールドエイジから呼び出した場合は、エラーになります。フィールドで指定された制約に動作が適合しない CodeInstance を呼び出した場合の動作は未定義です。owner !== nothing を持つ一部のコードインスタンス(外部コンパイラーが生成したものなど)は、プリコンパイルを経た後に呼び出すとエラーになる場合があります。これは、外部コンパイラープラグインでの使用を想定した高度なインターフェースです。
Examples
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)
IntegerBase.@invoke — Macro
@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)に展開されます
Examples
julia> @macroexpand @invoke f(x::T, y)
:(Core.invoke(f, Base.Tuple{T, Core.Typeof(y)}, x, y))
julia> @invoke 420::Integer % Unsigned
0x00000000000001a4
julia> @macroexpand @invoke (x::X).f
:(Core.invoke(Base.getproperty, Base.Tuple{X, Core.Typeof(:f)}, x, :f))
julia> @macroexpand @invoke (x::X).f = v::V
:(Core.invoke(Base.setproperty!, Base.Tuple{X, Core.Typeof(:f), V}, x, :f, v))
julia> @macroexpand @invoke (xs::Xs)[i::I]
:(Core.invoke(Base.getindex, Base.Tuple{Xs, I}, xs, i))
julia> @macroexpand @invoke (xs::Xs)[i::I] = v::V
:(Core.invoke(Base.setindex!, Base.Tuple{Xs, V, I}, xs, v, i))Base.invokelatest — Function
invokelatest(f, args...; kwargs...)f(args...; kwargs...)を呼び出しますが、fの最新のメソッドが実行されることを保証します。これは、長時間実行されるイベントループや、関数の古いバージョンを呼び出す可能性のあるコールバック関数など、特殊な状況で役立ちます。f(ただし、invokelatestはfを直接呼び出すよりやや遅く、結果の型をコンパイラーが推論できないという欠点があります)。
Base.@invokelatest — Macro
@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 — Keyword
new, or new{A,B,...}内部コンストラクターで使用できる特殊関数で、その型の新しいオブジェクトを生成します。new{A,B,...}という形式では、パラメトリック型のパラメーター値を明示的に指定します。詳しくは、マニュアルのInner Constructor Methodsを参照してください。
Base.:∘ — Function
f ∘ g関数の合成: つまり、(f ∘ g)(args...; kwargs...) は f(g(args...; kwargs...)) を意味します。∘ 記号は、Julia REPL(および適切に設定されたほとんどのエディタ)で \circ<tab> と入力すると入力できます。
関数合成は前置形式でも使えます。∘(f, g) は f ∘ g と同じです。前置形式では、複数の関数を合成する ∘(f, g, h) = f ∘ g ∘ h や、反復可能な関数コレクションを合成するためのスプラッティング ∘(fs...) も使えます。∘ の最後の引数が最初に実行されます。
Examples
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.0ComposedFunction、!f::Function も参照してください。
Base.ComposedFunction — Type
ComposedFunction{Outer,Inner} <: Function2つの呼び出し可能オブジェクト 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∘ も参照してください。
Base.splat — Function
splat(f)次と同等です。
my_splat(f) = args->f(args...)つまり、関数を受け取り、その関数に1つの引数を渡す新しい関数を返します。この引数は、元の関数にスプラット展開して渡されます。複数の引数を取る関数を、単一の引数を受け取ることが期待されるコンテキストで使う際に便利なアダプターです。そのコンテキストでは、タプルが単一の引数として渡されます。
Examples
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))
6Base.Returns — Type
f = Returns(value)f が f(args...; kw...) === value を満たすような呼び出し可能オブジェクトを作成します。
Examples
julia> f = Returns(42);
julia> f(1)
42
julia> f("hello", x=32)
42
julia> f.value
42Syntax
Base.@eval — Macro
@eval [mod,] exevalを使って、値を式に補間して評価します。引数が2つ指定された場合、1つ目の引数は評価を行うモジュールです。
Base.evalfile — Function
evalfile(path::AbstractString, args::Vector{String}=String[])ファイルをincludeを使って無名モジュールに読み込み、すべての式を評価して、最後の式の値を返します。省略可能なargs引数を使うと、スクリプトの入力引数(つまり、グローバルなARGS変数)を設定できます。メソッドやグローバル変数などの定義は無名モジュール内で評価され、現在のモジュールには影響しません。
Examples
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")Base.@inbounds — Macro
@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@inbounds を使用すると、範囲外のインデックスに対して誤った結果が返されたり、クラッシュやデータ破損が発生したりする可能性があります。手動でのチェックはユーザーの責任です。すべてのアクセスが範囲内であると確信できる場合に限り、@inbounds を使用してください(この前提に違反すると、クラッシュなどの未定義動作が発生する可能性があります)。たとえば、上記のような関数で eachindex(A) の代わりに 1:length(A) を使用しても、安全に範囲内であるとは限りません。A の最初のインデックスは、AbstractArray のサブタイプであるすべてのユーザー定義型で 1 になるとは限らないためです。
Base.@boundscheck — Macro
@boundscheck(blk)式 blk を境界チェックブロックとして注釈し、@inbounds によって省略できるようにします。
Examples
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]"@boundscheck 注釈を付けると、ライブラリの作成者は、@inbounds を使って 他のコード が境界チェックを削除できるようにすることを選択できます。そこで述べられているように、呼び出し元は @inbounds を使う前に、自身が利用できる情報に基づいてアクセスが有効であることを確認する必要があります。たとえば、独自の AbstractArray サブクラスをインデックス指定する場合は、その axes に対してインデックスをチェックします。したがって、@boundscheck 注釈は、getindex または setindex! の実装が正しく動作すると確信できた場合にのみ追加してください。
Base.@propagate_inbounds — Macro
@propagate_inbounds呼び出し元の inbounds コンテキストを保持したまま関数をインライン化するよう、コンパイラに指示します。
Base.@inline — Macro
@inlineこの関数をインライン化する価値があることを、コンパイラーにヒントとして伝えます。
小さな関数には通常、@inline注釈は必要ありません。コンパイラーが自動的にインライン化するためです。大きな関数に@inlineを使うと、インライン化するようコンパイラーにさらに促すことができます。
@inlineは、関数定義の直前、または関数本体内に適用できます。
# annotate long-form definition
@inline function longdef(x)
...
end
# annotate short-form definition
@inline shortdef(x) = ...
# annotate anonymous function that a `do` block creates
f() do
@inline
...
end@inline blockblock内の呼び出しをインライン化する価値があることを、コンパイラーにヒントとして伝えます。
# The compiler will try to inline `f`
@inline f(...)
# The compiler will try to inline `f`, `g` and `+`
@inline f(...) + g(...)呼び出し箇所の注釈は、呼び出される関数の定義に適用された注釈よりも常に優先されます。
@noinline function explicit_noinline(args...)
# body
end
let
@inline explicit_noinline(args...) # will be inlined
end呼び出し箇所の注釈は、そのブロック内のすべての呼び出しに適用されます。呼び出し自体が関数の引数になっている場合も含みます。
# The compiler will not inline `getproperty`, `g` or `f`
@noinline f(x.inner, g(y))呼び出し箇所の注釈が入れ子になっている場合は、最も内側の注釈が優先されます。
@noinline let a0, b0 = ...
a = @inline f(a0) # the compiler will try to inline this call
b = f(b0) # the compiler will NOT try to inline this call
return a, b
endBase.@noinline — Macro
@noinline関数をインライン化しないよう、コンパイラーにヒントを与えます。
小さな関数は通常、自動的にインライン化されます。小さな関数に@noinlineを使用すると、自動インライン化を防げます。
@noinlineは、関数定義の直前、または関数本体内で使用できます。
# annotate long-form definition
@noinline function longdef(x)
...
end
# annotate short-form definition
@noinline shortdef(x) = ...
# annotate anonymous function that a `do` block creates
f() do
@noinline
...
end@noinline blockblock内の呼び出しをインライン化しないよう、コンパイラーにヒントを与えます。
# The compiler will try to not inline `f`
@noinline f(...)
# The compiler will try to not inline `f`, `g` and `+`
@noinline f(...) + g(...)呼び出し箇所の注釈は、呼び出される関数の定義に適用された注釈よりも常に優先されます。
@inline function explicit_inline(args...)
# body
end
let
@noinline explicit_inline(args...) # will not be inlined
end呼び出し箇所の注釈が入れ子になっている場合は、最も内側の注釈が優先されます。
@inline let a0, b0 = ...
a = @noinline f(a0) # the compiler will NOT try to inline this call
b = f(b0) # the compiler will try to inline this call
return a, b
endBase.@nospecialize — Macro
@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@nospecialize はコード生成に影響しますが、推論には影響しません。生成されるネイティブコードの多様性は制限されますが、型推論には(標準的な制限を除き)制約を課しません。推論も抑制するには、Base.@nospecializeinfer と @nospecialize を併用してください。
Examples
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 g(A::AbstractArray)::Float64
└── return %1
) => Float64ここでは、@nospecialize アノテーションにより、次と同等の処理が行われます。
f(A::AbstractArray) = invoke(g, Tuple{AbstractArray}, A)これにより、g に対して生成されるネイティブコードは1種類だけとなり、あらゆる AbstractArray に対応する汎用的なものになります。ただし、g と f のどちらについても、具体的な戻り値の型は引き続き推論されます。また、その推論結果は f と g の呼び出し元を最適化する際にも引き続き使われます。
Base.@specialize — Macro
@specialize引数の特殊化ヒントをデフォルトに戻します。詳しくは、@nospecialize を参照してください。
Base.@nospecializeinfer — Macro
Base.@nospecializeinfer function f(args...)
@nospecialize ...
...
end
Base.@nospecializeinfer f(@nospecialize args...) = ...コンパイラーに、@nospecialize の引数の宣言型を使って f を推論するよう指示します。推論時にコンパイラーが生成する特殊化の数を制限するために使用できます。
Examples
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 g(A::AbstractArray)::Any
└── return %1
) => Anyこの例では、f は A の具体的な型ごとに推論されます。一方、g は、宣言された引数型 A::AbstractArray を使って一度だけ推論されます。そのため、具体的な戻り値の型を推論できない場合でも、コンパイラーで過剰な推論時間が発生する可能性は低くなります。@nospecializeinfer がない場合、f([1.0]) は g の戻り値の型を Float64 と推論します。これは、特殊化されたコードの生成が禁止されているにもかかわらず、g(::Vector{Float64}) の推論が実行されたことを示しています。
Base.@constprop — Macro
Base.@constprop setting [ex]注釈を付けた関数に対する、関数間定数伝播のモードを制御します。
次の2つのsettingがサポートされています。
Base.@constprop :aggressive [ex]: 定数伝播を積極的に適用します。戻り値の型が引数の値に依存するメソッドでは、コンパイル時間が増える代わりに、型推論の結果が改善されることがあります。Base.@constprop :none [ex]: 定数伝播を無効にします。Juliaが通常なら定数伝播の対象と判断する関数では、コンパイル時間を短縮できる場合があります。よくある例として、BoolまたはSymbolの値を取る引数やキーワード引数を持つ関数があります。
Base.@constpropは、関数定義の直前、または関数本体内で使用できます。
# annotate long-form definition
Base.@constprop :aggressive function longdef(x)
...
end
# annotate short-form definition
Base.@constprop :aggressive shortdef(x) = ...
# annotate anonymous function that a `do` block creates
f() do
Base.@constprop :aggressive
...
endBase.gensym — Function
gensym([tag])(同じモジュール内の)ほかの変数名と衝突しないシンボルを生成します。
Base.@gensym — Macro
@gensym変数用の gensym シンボルを生成します。たとえば、@gensym x y は x = gensym("x"); y = gensym("y") に変換されます。
var"name" — Keyword
var構文 var"#example#" は、Symbol("#example#") という名前の変数を参照します。ただし、#example# は有効な Julia 識別子名ではありません。
これは、有効な識別子の構成規則が異なるプログラミング言語との相互運用に役立つことがあります。たとえば、R 変数 draw.segments を参照するには、Julia コードで var"draw.segments" を使用できます。
また、マクロ衛生処理を経た Julia ソースコードや、通常の方法では解析できない変数名を含むソースコードを show するためにも使われます。
この構文にはパーサーのサポートが必要です。通常の文字列マクロ @var_str として実装されるのではなく、パーサーによって直接展開されます。
Base.@goto — Macro
@goto name@goto name は、@label name の位置にある文へ無条件にジャンプします。
@label と @goto では、異なるトップレベルの文へのジャンプを作成できません。これを試みるとエラーになります。それでも @goto を使用するには、@label と @goto をブロックで囲みます。
Base.@label — Macro
@label name文に記号ラベル name を付けます。このラベルは、@goto name を伴う無条件ジャンプの終点を示します。
Base.SimdLoop.@simd — Macro
@simdコンパイラーがループの順序を入れ替えられるよう、for ループに注釈を付けて、より自由に最適化できるようにします。
@simd for ループで反復処理する対象は、1 次元の範囲である必要があります。@simd を使用すると、ループについて次の性質を満たすことを表明します。
- リダクション変数に特別な配慮をしたうえで、反復を任意の順序、または重複する順序で安全に実行できる。
- リダクション変数に対する浮動小数点演算の順序を入れ替えたり、演算を融合したりできる。その結果、
@simdを使用しない場合とは異なる結果になる可能性がある。
多くの場合、Julia は @simd を使わなくても、内側の for ループを自動的にベクトル化できます。@simd を使うと、より多くの状況でベクトル化できるよう、コンパイラーに多少の裁量を与えられます。どちらの場合も、内側のループをベクトル化するには、次の性質が必要です。
- ループは最内ループであること。
- ループ本体は直線的なコードであること。そのため、現在は配列へのすべてのアクセスに
@inboundsが必要です。すべてのオペランドを無条件に評価しても安全な場合、コンパイラーは短い&&、||、?:式を直線的なコードに変換できることがあります。安全に実行できる場合は、ループ内で?:の代わりにifelse関数を使うことを検討してください。 - アクセスにはストライドパターンが必要であり、「ギャザー」(ランダムインデックスによる読み取り)や「スキャッター」(ランダムインデックスによる書き込み)は使用できません。
- ストライドは単位ストライドであること。
@simd は、デフォルトではループ伝搬メモリー依存が完全に存在しないことを表明しません。これは汎用コードでは簡単に破られうる前提です。汎用でないコードを書く場合は、@simd ivdep for ... end を使って、次の点も表明できます。
- ループ伝搬メモリー依存が存在しない。
- 反復が、前の反復による進行を待つことがない。
Base.@polly — Macro
@polly関数にポリヘドラル最適化器 Polly を適用するよう、コンパイラに指示します。
Base.@generated — Macro
@generated f@generatedは、生成される関数を注釈するために使用します。生成された関数の本体では、引数の型のみを読み取ることができ、値は読み取れません。この関数は、呼び出し時に評価される引用式を返します。グローバルスコープを変更する関数や、変更可能な要素に依存する関数には、@generatedマクロを使用しないでください。
詳しくはMetaprogrammingを参照してください。
Examples
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 — Macro
Base.@assume_effects setting... [ex]コンパイラーのエフェクト解析をオーバーライドします。このマクロは、次のような複数のコンテキストで使用できます。
- メソッド定義の直前に置き、対象メソッドのエフェクト解析全体をオーバーライドする。
- 引数なしで関数本体内に置き、包含するメソッドのエフェクト解析全体をオーバーライドする。
- コードブロックに適用し、対象コードブロックのローカルなエフェクト解析をオーバーライドする。
Examples
julia> Base.@assume_effects :terminates_locally function fact(x)
# usage 1:
# this :terminates_locally allows `fact` to be constant-folded
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
# usage 2:
# this :terminates_locally allows this anonymous function to be constant-folded
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")
# usage 3:
# with this :terminates_locally annotation the compiler skips tainting
# `:terminates` effect within this `while` block, allowing the parent
# anonymous function to be constant-folded
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}このマクロを不適切に使用すると、未定義動作(クラッシュ、誤った結果、その他追跡が困難なバグを含む)が発生します。慎重に扱い、絶対に必要な場合の最後の手段としてのみ使用してください。その場合でも、エフェクトのアサーションをできる限り弱めるためのあらゆる手段を講じるべきです(たとえば、:nothrow で十分な場合に :total を使わないでください)。
一般に、各 setting 値は、コンパイラーがその動作を証明することなく、関数の動作についてアサーションを行います。これらのアサーションは、すべてのワールドエイジに対して行われます。そのため、後から拡張されて前提を無効にする可能性のあるジェネリック関数の使用は制限することをお勧めします(前提が無効になると未定義動作が発生します)。
次の setting がサポートされています。
:consistent:effect_free:nothrow:terminates_globally:terminates_locally:notaskstate:inaccessiblememonly:noub:noub_if_noinbounds:nortcall:foldable:removable:total
Extended help
:consistent
:consistent の設定は、egal(===)な入力に対して、次のことをアサートします。
- 終了の仕方(戻り値、例外、非終了)は常に同じである。
- メソッドが戻る場合、結果は常に egal である。
:consistent-cy アサーションは、特定のワールド範囲 R に対して行われます。より形式的には、ワールドエイジ $i$ における $f$ の評価を $fᵢ$ と表すと、この設定は次を要求します。
\[∀ i ∈ R, j ∈ R, x, y: x ≡ y → fᵢ(x) ≡ fⱼ(y)\]
@assume_effects の場合、範囲 R は、注釈対象またはそれを含むメソッドの m.primary_world:m.deleted_world です。
通常のコードインスタンスでは、R は ci.min_world:ci.max_world です。
さらに、:consistent 関数は、指定されたワールドエイジ範囲内で一定でないヒープの状態やその他のグローバル状態に依存して戻り値を決めてはならないことも意味します。
:consistent-cy には、オプティマイザーが行うすべての合法な書き換えが含まれます。たとえば、浮動小数点数に対する fastmath 演算は :consistent とは見なされません。オプティマイザーが書き換えを行うと、同じワールドエイジであっても出力が :consistent でなくなる可能性があるためです(たとえば、一方がインタープリターで実行され、もう一方が最適化されて実行された場合)。
:effect_free
:effect_free の設定は、メソッドに外部から意味的に観測可能な副作用がないことをアサートします。外部から意味的に観測可能な副作用の例を以下に示します(ただし、これらに限りません)。
- グローバル変数の値を変更する。
- 以下に記載する場合を除き、ヒープ(配列や可変値など)を変更する。
- メソッドテーブルを変更する(たとえば、eval の呼び出しによる変更)。
- ファイル、ネットワークなどへの入出力。
- タスクの切り替え。
一方、観測可能な場合があっても、次のものは意味的に観測可能な副作用とは明示的に見なされません。
- メモリの割り当て(可変・不変の両方)。
- 経過時間。
- ガベージコレクション。
- メソッドの実行期間を超えて存続しないオブジェクト(つまり、メソッド内で割り当てられ、外部に逃げないオブジェクト)のヒープ変更。
- 戻り値(外部からは見えますが、副作用ではありません)。
目安としては、関数が実行されなかった場合にプログラムの残りの実行に影響するものは、外部から観測可能な副作用です。
:effect_free アサーションは、メソッド自体と、そのメソッドによって実行されるすべてのコードに対して適用されます。このアサーションはすべてのワールドエイジで有効でなければならないため、使用は適切に制限してください。
:nothrow
:nothrow の設定は、このメソッドが例外を投げないこと(つまり、値を返すか、戻らないかのいずれかであること)をアサートします。
メソッドの実行によって MethodError などの例外が発生する可能性がある場合、そのメソッドは :nothrow とは見なされません。ただし、StackOverflowError や InterruptException のような環境依存のエラーは、このエフェクトではモデル化されません。そのため、StackOverflowError になる可能性のあるメソッドが、必ずしも !:nothrow である必要はありません(ただし、通常は !:terminates でもあるべきです)。
:terminates_globally
:terminates_globally の設定は、このメソッドが最終的に(正常または異常に)終了し、無限ループしないことをアサートします。
コンパイラーは、この設定をメソッドが比較的速く終了する強い根拠と見なし、(他の条件が許せば)コンパイル時にこのメソッドを呼び出すことがあります。つまり、技術的には終了するものの、実用上は終了しないようなメソッドにこの設定を付けるのは得策ではありません。
:terminates_locally
:terminates_locally の設定は :terminates_globally と似ていますが、注釈対象メソッド内の構文上の制御フローにのみ適用されます。そのため、より弱く安全性の高いアサーションであり、終了しない別のメソッドを呼び出した場合には、注釈対象メソッド自体が終了しない可能性を許容します。
:notaskstate
:notaskstate の設定は、このメソッドがタスクローカルストレージや RNG の状態など、ローカルなタスク状態を使用も変更もしないことをアサートします。そのため、観測可能な結果を変えることなく、タスク間で安全に移動できます。
例外処理の実装では、タスクオブジェクトに保存された状態を使用します。ただし、この状態は現在 :notaskstate の対象範囲とは見なされず、:nothrow エフェクトによって別途追跡されます。
:notaskstate アサーションが対象とするのは、現在実行中のタスクの状態です。どのタスクが現在実行中かを考慮しない別の手段で Task オブジェクトへの参照を取得した場合、:notaskstate エフェクトは汚染されないことがあります。そのタスクオブジェクトが現在実行中のタスクに対して === であっても同様です。
タスク状態へのアクセスは、通常、他のエフェクトも汚染します。たとえば、タスク状態を変更する場合は :effect_free、結果の計算にタスク状態を使用する場合は :consistent が汚染されます。特に、:notaskstate ではないものの、:effect_free かつ :consistent であるコードは、依然としてデッドコード除去の対象となり、:total に昇格することがあります。
:inaccessiblememonly
:inaccessiblememonly の設定は、このメソッドが外部からアクセス可能な可変メモリにアクセスも変更もしないことをアサートします。つまり、メソッドから戻る前に他のメソッドやトップレベルの実行からアクセスできない新規割り当てオブジェクトの可変メモリであれば、アクセスや変更が可能です。一方、可変なグローバル状態や、引数が指す可変メモリにはアクセスも変更もできません。
この前提を無効にする例を以下に示します(ただし、これらに限りません)。
- グローバル参照、または可変なグローバル変数にアクセスする
getglobal呼び出し。 - グローバルへの代入、または定数でないグローバル変数に代入する
setglobal!呼び出し。 - グローバルな可変変数のフィールドを変更する
setfield!呼び出し。
:noub
:noub の設定は、このメソッドが(どのような入力に対しても)未定義動作を実行しないことをアサートします。未定義動作によって、:consistent や :effect_free など、他のエフェクトに関するアサーションにも違反する可能性はあります。しかし、これはモデル化されておらず、各エフェクトは未定義動作がないことを前提としています。
:nortcall
:nortcall の設定は、このメソッドが Core.Compiler.return_type を呼び出さず、また、このメソッドが呼び出す可能性のある他のメソッドも Core.Compiler.return_type を呼び出さないことをアサートします。
厳密には、実行時に Core.Compiler.return_type の呼び出しが行われない場合、つまり Core.Compiler.return_type の結果がコンパイル時に正確に判明し、オプティマイザーによって呼び出しが除去される場合には、このアサーションを使用できます。ただし、Core.Compiler.return_type の結果がコンパイル時に定数畳み込みされるかどうかは、コンパイラーの実装に大きく依存します。そのため、対象メソッドが何らかの形で Core.Compiler.return_type を使用する場合、このアサーションを行うのは一般に危険です。
:foldable
この設定は、コンパイル時に呼び出しを定数畳み込みするためにコンパイラーが保証を必要とするエフェクト一式を、簡潔に指定するものです。現在は、次の setting と同等です。
:consistent:effect_free:terminates_globally:noub:nortcall
このリストには、特に :nothrow が含まれていません。コンパイラーは引き続き定数伝播を試み、コンパイル時に発生したエラーを記録します。ただし、:consistent-cy の要件により、この注釈が付いた呼び出しは、同じ引数値に対して常に一貫して例外を投げなければなりません。
:removable
この設定は、コンパイル時に結果が使われない呼び出しを確実に除去するためにコンパイラーが必要とするエフェクト一式を、簡潔に指定するものです。現在は、次の setting と同等です。
:effect_free:nothrow:terminates_globally
:total
この setting は、可能な限り最大のエフェクト集合です。現在、次の他の setting を含意します。
:consistent:effect_free:nothrow:terminates_globally:notaskstate:inaccessiblememonly:noub:nortcall
:total は非常に強いアサーションであり、Julia の将来のバージョンでは追加の意味が加わる可能性があります(たとえば、エフェクトが追加され、:total の定義に含まれる場合)。そのため、慎重に使用してください。可能な限り、用途に必要な最小限の具体的なエフェクトアサーションを使用してください。多数のエフェクトのオーバーライドを複数の関数に適用する場合は、:total を使うより、カスタムマクロを使うことをお勧めします。
Negated effects
エフェクト名の前に ! を付けると、先行するメタエフェクトからそのエフェクトを取り除くことを示せます。たとえば、:total !:nothrow は、呼び出しが一般には全域的である一方、例外を投げる可能性があることを示します。
Managing deprecations
Base.@deprecate — Macro
@deprecate old new [export_old=true]メソッド old を非推奨にし、置き換え後の呼び出しとして new を指定します。その際、指定されたシグネチャを持つ新しいメソッド old を定義します。
old がエクスポートされないようにするには、export_old を false に設定します。
関連項目: Base.depwarn()。
Julia 1.5 以降では、@deprecate で定義された関数は、--depwarn=yes フラグを設定せずに julia を実行しても警告を出力しません。これは、--depwarn オプションのデフォルト値が no であるためです。警告は、Pkg.test() が実行するテストから出力されます。
Examples
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 の位置引数とキーワード引数を任意の数だけ受け取る、非推奨のメソッドが定義されます。
Julia 1.9 以降では、型注釈を明示しない場合、キーワード引数も転送されます。それ以前のバージョンでは、@deprecate old(args...; kwargs...) new(args...; kwargs...) のようにして、位置引数とキーワード引数を手動で転送できます。
非推奨化の対象を特定のシグネチャに限定するには、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 — Function
Base.depwarn(msg::String, funcsym::Symbol; force=false)msg を非推奨警告として出力します。シンボル funcsym には呼び出し元の関数名を指定します。これは、呼び出し箇所ごとに最初の1回だけ非推奨警告を出力するために使われます。force=true を設定すると、Julia の起動時に --depwarn=no(デフォルト)が指定されていても、警告が常に表示されます。
@deprecate を参照してください。
Examples
function deprecated_func()
Base.depwarn("Don't use `deprecated_func()`!", :deprecated_func)
1 + 1
endMissing Values
Base.Missing — Type
Missingフィールドを持たない型で、そのシングルトンインスタンス missing は欠損値を表すために使われます。
関連項目: skipmissing、nonmissingtype、Nothing。
Base.missing — Constant
Base.coalesce — Function
coalesce(x...)引数の中でmissingと等しくない最初の値を返します。該当する値がない場合は、missingを返します。
関連項目:skipmissing、something、@coalesce。
Examples
julia> coalesce(missing, 1)
1
julia> coalesce(1, missing)
1
julia> coalesce(nothing, 1) # returns `nothing`
julia> coalesce(missing, missing)
missingBase.@coalesce — Macro
@coalesce(x...)coalesceの短絡評価版。
Examples
julia> f(x) = (println("f($x)"); missing);
julia> a = 1;
julia> a = @coalesce a f(2) f(3) error("`a` is still missing")
1
julia> b = missing;
julia> b = @coalesce b f(2) f(3) error("`b` is still missing")
f(2)
f(3)
ERROR: `b` is still missing
[...]Base.ismissing — Function
Base.skipmissing — Function
skipmissing(itr)itr の要素を、missing の値を除いて返すイテレータです。返されるオブジェクトは、itr がインデックス可能であれば、そのインデックスを使ってアクセスできます。欠損値に対応するインデックスは無効です。keys と eachindex ではスキップされ、使用しようとすると MissingException がスローされます。
collect を使うと、itr に含まれる missing 以外の値を格納した Array を取得できます。itr が多次元配列であっても、結果は常に Vector になります。入力の次元を保ったまま欠損値を取り除くことはできないためです。
関連項目: coalesce、ismissing、something。
Examples
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
2Base.nonmissingtype — Function
nonmissingtype(T::Type)T が Missing を含む型のユニオンである場合、Missing を取り除いた新しい型を返します。
Examples
julia> nonmissingtype(Union{Int64,Missing})
Int64
julia> nonmissingtype(Any)
AnySystem
Base.run — Function
run(command, args...; wait::Bool = true)バッククォートで構築したコマンドオブジェクトを実行します(マニュアルのRunning External Programsセクションを参照)。何らかの問題が発生するとエラーをスローします。これには、waitがtrueの場合に、プロセスがゼロ以外のステータスで終了することも含まれます。
args...を使うと、ファイル記述子をコマンドに渡せます。通常のUnixファイル記述子と同じ順序で指定します(例:stdin, stdout, stderr, FD(3), FD(4)...)。
waitがfalseの場合、プロセスは非同期で実行されます。後からwaitを使ってプロセスを待機し、返されたプロセスオブジェクトに対してsuccessを呼び出すことで終了ステータスを確認できます。commandが単一のプロセスのみを起動する場合は、Processオブジェクトが返され、exitcodeフィールドから終了コードを取得できます。詳しくはwaitを参照してください。
waitがfalseの場合、プロセスのI/Oストリームはdevnullに接続されます。waitがtrueの場合、I/Oストリームは親プロセスと共有されます。I/Oのリダイレクトを制御するには、pipelineを使用してください。
関連項目:Cmd。
Base.devnull — Constant
devnullストリームのリダイレクト先として使用し、書き込まれたデータをすべて破棄します。Unix の /dev/null、または Windows の NUL とほぼ同等です。使用例:
run(pipeline(`cat test.txt`, devnull))Base.success — Function
success(command)バッククォートで構築したコマンドオブジェクト(マニュアルのRunning External Programsのセクションを参照)を実行し、成功したかどうか(終了コードが0かどうか)を判定します。プロセスを起動できない場合は例外が発生します。
Base.process_running — Function
process_running(p::Process)プロセスが現在実行中かどうかを判定します。
Base.process_exited — Function
process_exited(p::Process)プロセスが終了したかどうかを判定します。
Base.Sys.set_process_title — Function
Sys.set_process_title(title::AbstractString)プロセスのタイトルを設定します。一部のオペレーティングシステムでは何も行いません。
Base.Sys.get_process_title — Function
Sys.get_process_title()プロセスのタイトルを取得します。一部のシステムでは、常に空文字列が返されます。
Base.ignorestatus — Function
ignorestatus(command)コマンドオブジェクトに印を付け、実行結果のコードがゼロ以外でもエラーが発生しないようにします。
Base.detach — Function
detach(command)コマンドオブジェクトに印を付け、新しいプロセスグループで実行されるようにします。これにより、Julia プロセスの終了後も実行を続けられ、Ctrl-C による割り込みも渡されません。
Base.Cmd — Type
Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir, uid, gid)
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: コマンドの作業ディレクトリを指定します(現在のディレクトリの代わりに使用されます)。uid::Union{Nothing,UInt32}: プロセスのユーザーIDを設定します(Unixのみ)。gid::Union{Nothing,UInt32}: プロセスのグループIDを設定します(Unixのみ)。
指定されていないキーワードについては、cmdの現在の設定が使用されます。
Cmd(exec)コンストラクターは、execのコピーを作成しないことに注意してください。その後execに加えた変更は、Cmdオブジェクトにも反映されます。
Cmdオブジェクトを作成する最も一般的な方法は、次のようにコマンドリテラル(バッククォート)を使うことです。
`ls -l`これをCmdコンストラクターに渡すことで、次のように設定を変更できます。
Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)Base.setenv — Function
setenv(command::Cmd, env; dir)指定した command の実行時に使用する環境変数を設定します。env には、文字列から文字列への対応を表す辞書、"var=val" 形式の文字列の配列、または 0 個以上の "var"=>val ペア引数を指定できます。既存の環境を置き換えるのではなく変更するには、env を copy(ENV) で作成してから、必要に応じて env["var"]=val を設定するか、addenv を使用します。
dir キーワード引数を使うと、コマンドの作業ディレクトリを指定できます。dir の既定値は、command に現在設定されている dir です(まだ指定されていない場合は、現在の作業ディレクトリになります)。
Base.addenv — Function
addenv(command::Cmd, env...; inherit::Bool = true)指定されたCmdオブジェクトに新しい環境変数のマッピングをマージし、新しいCmdオブジェクトを返します。キーが重複する場合は置き換えられます。commandに環境変数の値がすでに設定されていない場合、inheritがtrueであれば、addenv()の呼び出し時点の現在の環境を引き継ぎます。値がnothingのキーは、環境変数から削除されます。
Base.withenv — Function
withenv(f, kv::Pair...)fを、setenvのように置き換えるのではなく、一時的に変更した環境で、0個以上の"var"=>val引数kvを使って実行します。withenvは、通常withenv(kv...) do ... end構文で使用します。nothingを指定すると、環境変数が設定されている場合に、一時的にその設定を解除できます。withenvが戻ると、元の環境に復元されます。
環境の変更はスレッドセーフではありません。親プロセスとは異なる環境で外部コマンドを実行する場合は、addenvをwithenvよりも優先して使用してください。
Base.shell_escape — Function
shell_escape(args::Union{Cmd,AbstractString...}; special::AbstractString="")非エクスポートのshell_escape関数は、非エクスポートのBase.shell_split()関数の逆関数です。文字列またはコマンドオブジェクトを受け取り、特殊文字をエスケープします。これにより、その結果にBase.shell_split()を適用すると、元のコマンドに含まれる単語の配列が得られます。specialキーワード引数では、空白、バックスラッシュ、引用符、ドル記号に加えて、どの文字を特殊文字として扱うかを指定します(デフォルト:なし)。
Examples
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"Base.shell_split — Function
shell_split(command::AbstractString)シェルコマンド文字列を個々の要素に分割します。
Examples
julia> Base.shell_split("git commit -m 'Initial commit'")
4-element Vector{String}:
"git"
"commit"
"-m"
"Initial commit"Base.shell_escape_posixly — Function
shell_escape_posixly(args::Union{Cmd,AbstractString...})非エクスポートのshell_escape_posixly関数は、文字列またはコマンドオブジェクトを受け取り、POSIXシェルに引数として安全に渡せるよう、特殊文字をエスケープします。
関連項目: Base.shell_escape()
Examples
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"Base.shell_escape_csh — Function
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_wincmd — Function
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))バッチファイルを呼び出す際に CMD が行う引数解析(.bat ファイル内での呼び出し、およびバッチファイルへの引数としての呼び出し)は、この関数の出力と完全には互換性がありません。特に、% の処理方法が異なります。
CMD パーサー/インタープリターの特殊な動作により、リテラルの | 文字(コマンドパイプラインを示す)の後にある各コマンドには、shell_escape_wincmd を2回適用する必要があります。CMD によって2回解析されるためです。つまり、環境変数も2回展開されます。たとえば、次のようになります。
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()。
Examples
julia> Base.shell_escape_wincmd("a^\"^o\"^u\"")
"a^^\"^o\"^^u^\""Base.escape_microsoft_c_args — Function
escape_microsoft_c_args(args::Union{Cmd,AbstractString...})
escape_microsoft_c_args(io::IO, args::Union{Cmd,AbstractString...})文字列引数の集合を、多くの Windows コマンドラインアプリケーションに渡せる文字列に変換します。
Microsoft Windows では、コマンドライン全体が単一の文字列としてアプリケーションに渡されます(POSIX システムでは、シェルがコマンドラインを引数のリストに分割します)。julia.exe を含む多くの Windows API アプリケーションは、Microsoft C/C++ runtime の規則に従って、そのコマンドラインを文字列のリストに分割します。
この関数は、これらの規則に準拠したパーサーの逆変換を実装します。Windows の C/C++/Julia アプリケーションに渡すコマンドライン引数を結合し、必要に応じて空白、TAB、二重引用符、バックスラッシュなどのメタ文字をエスケープまたは引用符で囲みます。
Base.shell_escape_wincmd()、Base.escape_raw_string() も参照してください。
Base.setcpuaffinity — Function
setcpuaffinity(original_command::Cmd, cpus) -> command::Cmdcommand の CPU アフィニティを、CPU ID(1 始まり)のリスト cpus で設定します。cpus = nothing を渡すと、original_command に CPU アフィニティが設定されている場合、それを解除します。
この関数は Linux と Windows でのみサポートされています。libuv がアフィニティの設定をサポートしていないため、macOS では利用できません。
Examples
Linux では、コマンドラインプログラム taskset を使って、setcpuaffinity の動作を確認できます。
julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13マスク値 13 は、最下位ビットから数えて1番目、2番目、5番目のビットがオンになっていることを表します。
julia> 0b010011
0x13Base.pipeline — Method
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`))Base.pipeline — Method
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))Base.Libc.gethostname — Function
gethostname()::Stringローカルマシンのホスト名を取得します。
Base.Libc.time — Method
Base.time_ns — Function
time_ns()::UInt64システム固有の任意の過去の時点を基準とした、ナノ秒単位の時刻を取得します。主な用途は、プログラムの実行中に経過時間を測定することです。返される値は、システムの稼働中は単調増加することが保証されています(2⁶⁴を法とする)。また、クロックのドリフトやローカルの暦時刻の変更の影響を受けません。ただし、システムの再起動やサスペンドをまたぐと、値が任意に変化することがあります。
(返される時刻は常にナノ秒単位ですが、時間分解能はプラットフォームによって異なります。)
Base.@time — Macro
@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 seconds (2.19 M allocations: 116.555 MiB, 3.75% gc time, 99.94% compilation time)
julia> @time x * x;
0.000009 seconds (1 allocation: 896 bytes)
julia> @time begin
sleep(0.3)
1+1
end
0.301395 seconds (8 allocations: 336 bytes)
2
julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 seconds (5 allocations: 144 bytes)
julia> for loop in 1:3
@time loop sleep(1)
end
1: 1.006760 seconds (5 allocations: 144 bytes)
2: 1.001263 seconds (5 allocations: 144 bytes)
3: 1.003676 seconds (5 allocations: 144 bytes)Base.@showtime — Macro
@showtime expr@timeと似ていますが、参照用に評価対象の式も出力します。
関連項目: @time。
julia> @showtime sleep(1)
sleep(1): 1.002164 seconds (4 allocations: 128 bytes)Base.@timev — Macro
@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: 1Base.@timed — Macro
@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
Base.@elapsed — Macro
@elapsed式を評価し、実行にかかった秒数を浮動小数点数で返します。評価結果の値は破棄されます。
場合によっては、システムが@elapsed式の内部を調べ、トップレベルの式の実行が始まる前に、呼び出されるコードの一部をコンパイルすることがあります。その場合、コンパイル時間の一部は計測されません。この時間も含めるには、@elapsed @eval ...を実行してください。
@time、@timev、@timed、@allocated、@allocationsも参照してください。
julia> @elapsed sleep(0.3)
0.301391426Base.@allocated — Macro
@allocated式を評価し、その結果の値を破棄して、評価中に割り当てられたバイト数の合計を返すマクロです。
式が関数呼び出しの場合、引数式の評価と関数の実行による割り当てのみを測定し、呼び出しに伴うオーバーヘッドを除外するとともに、指定された引数値を使った定数伝播を行わないようにします。これらの影響も含めて、つまり呼び出し箇所全体を測定したい場合は、次の構文を使用してください。@allocated (()->f(1))()
関数呼び出しを測定する際は、引数式を単純なものにすることをお勧めします。たとえば、@allocated f([])ではなくx = []; @allocated f(x)を使うと、測定対象がfのみであることが明確になります。
より複雑な式は、その場でそのまま実行されるため、周囲のコンテキストに起因する割り当てが発生する場合があります。たとえば、@allocated f(1)と@allocated x = f(1)では、結果が異なることがあります。
関連項目:@allocations、@time、@timev、@timed、@elapsed。
julia> @allocated rand(10^6)
8000080Base.@allocations — Macro
@allocations式を評価し、その結果の値を破棄して、式の評価中に発生した割り当ての総数を返すマクロです。
関連項目: @allocated、@time、@timev、@timed、@elapsed。
julia> @allocations rand(10^6)
2Base.@lock_conflicts — Macro
@lock_conflicts式を評価してその結果を破棄し、代わりに評価中に発生したロック競合の総数を返すマクロです。ロックがすでに保持されていたため、ReentrantLockへのロック取得が待機状態になった場合に、ロック競合として数えます。
julia> @lock_conflicts begin
l = ReentrantLock()
Threads.@threads for i in 1:Threads.nthreads()
lock(l) do
sleep(1)
end
end
end
5Base.TRACE_EVAL — Constant
Base.TRACE_EVALトップレベル評価中の式トレースを全体的に制御します。この設定は、--trace-eval コマンドラインオプションより優先されます。
設定値:
nothing- コマンドラインの--trace-eval設定を使用します(デフォルト):no- 式トレースを無効にします:loc- 評価中は位置情報のみを表示します:full- 評価中の式全体を表示します
Examples
# Enable full expression tracing
Base.TRACE_EVAL = :full
# Show only locations
Base.TRACE_EVAL = :loc
# Disable tracing (overrides command-line setting)
Base.TRACE_EVAL = :no
# Reset to use command-line setting
Base.TRACE_EVAL = nothing関連項目: Command-line Interface(--trace-eval オプション)。
Base.EnvDict — Type
EnvDict()::EnvDictこの型のシングルトンは、環境変数に対するハッシュテーブルのインターフェースを提供します。
Base.ENV — Constant
ENVシステム環境変数への辞書インターフェースを提供する、シングルトンEnvDictへの参照です。
(Windowsでは、システム環境変数の大文字と小文字は区別されません。そのため、ENVは、表示、反復処理、コピーの際にすべてのキーを大文字に変換します。移植性のあるコードでは、大文字と小文字の違いによって変数を区別できることを前提にしないでください。また、小文字で指定したつもりの変数を設定すると、キーが大文字のENVになる場合があることにも注意してください。)
Examples
julia> ENV
Base.EnvDict with "50" entries:
"SECURITYSESSIONID" => "123"
"USER" => "username"
"MallocNanoZone" => "0"
⋮ => ⋮
julia> ENV["JULIA_EDITOR"] = "vim"
"vim"
julia> ENV["JULIA_EDITOR"]
"vim"Base.Sys.STDLIB — Constant
Sys.STDLIB::Stringstdlib パッケージが格納されているディレクトリのフルパスを表す文字列。
Base.Sys.isunix — Function
Sys.isunix([os])OSがUnix系のインターフェースを提供しているかどうかを判定する述語です。詳細はHandling Operating System Variationのドキュメントを参照してください。
Base.Sys.isapple — Function
Sys.isapple([os])OSがApple Macintosh OS XまたはDarwinの派生版かどうかを判定する述語です。詳しくはHandling Operating System Variationを参照してください。
Base.Sys.islinux — Function
Sys.islinux([os])OSがLinuxの派生版かどうかを判定する述語です。詳細はHandling Operating System Variationを参照してください。
Base.Sys.isbsd — Function
Sys.isbsd([os])OSがBSDの派生系かどうかを判定する述語です。詳しくはHandling Operating System Variationを参照してください。
Base.Sys.isfreebsd — Function
Sys.isfreebsd([os])OS が FreeBSD 派生かどうかを判定する述語です。Handling Operating System Variation のドキュメントを参照してください。
Base.Sys.isopenbsd — Function
Sys.isopenbsd([os])OSがOpenBSDの派生版かどうかを判定する述語です。ドキュメントはHandling Operating System Variationを参照してください。
Base.Sys.isnetbsd — Function
Sys.isnetbsd([os])OSがNetBSDの派生OSかどうかを判定する述語です。詳細はHandling Operating System Variationを参照してください。
Base.Sys.isdragonfly — Function
Sys.isdragonfly([os])OS が DragonFly BSD の派生であるかどうかを判定する述語です。Handling Operating System Variation のドキュメントを参照してください。
Base.Sys.iswindows — Function
Sys.iswindows([os])OSがMicrosoft Windows NTの派生版かどうかを判定する述語です。詳細はHandling Operating System Variationのドキュメントを参照してください。
Base.Sys.windows_version — Function
Sys.windows_version()Windows NT カーネルのバージョン番号を VersionNumber として返します。つまり、v"major.minor.build" です。Windows 上で実行されていない場合は、v"0.0.0" を返します。
Base.Sys.free_memory — Function
Sys.free_memory()RAMの空きメモリの合計をバイト単位で取得します。
Base.Sys.total_memory — Function
Sys.total_memory()RAMの総メモリ量(現在使用中の分を含む)をバイト単位で取得します。この量は、Linuxのコントロールグループなどによって制限される場合があります。制限のないメモリ量については、Sys.total_physical_memory()を参照してください。
Base.Sys.free_physical_memory — Function
Sys.free_physical_memory()システムの空きメモリ量をバイト単位で取得します。この全量を現在のプロセスで利用できるとは限りません。実際に利用可能な量を取得するには、Sys.free_memory() を使用してください。
Base.Sys.total_physical_memory — Function
Sys.total_physical_memory()RAMの総メモリ容量(現在使用中の分を含む)をバイト単位で取得します。その全容量を現在のプロセスで利用できるとは限りません。Sys.total_memory()。
Base.Sys.uptime — Function
Sys.uptime()現在のシステム稼働時間を秒単位で取得します。
Base.Sys.sysimage_target — Function
Sys.sysimage_target()現在のシステムイメージのビルドに使用された CPU ターゲット文字列を返します。
この関数は、システムイメージのコンパイル時に Julia に渡された元の CPU ターゲット指定を返します。同じシステムイメージを再現したり、コンパイル時に有効になっていた CPU 機能を確認したりする際に役立ちます。
システムイメージがデフォルト設定でビルドされている場合は、"native" を返します。
関連項目: JULIA_CPU_TARGET。
Base.Sys.isjsvm — Function
Sys.isjsvm([os])Julia が JavaScript VM(JSVM)上で実行されているかどうかを判定する述語です。たとえば、Web ブラウザーに組み込まれた WebAssembly JavaScript 環境などが該当します。
Base.Sys.loadavg — Function
Sys.loadavg()ロードアベレージを取得します。詳細は https://en.wikipedia.org/wiki/Load_(computing). を参照してください。
Base.Sys.isexecutable — Function
isexecutable(path::String)指定されたpathに実行権限がある場合は、trueを返します。
ユーザーがpathを実行する前に、この権限が変更される可能性があります。そのため、先にisexecutableを呼び出すよりも、ファイルを実行し、失敗した場合はエラーを処理することを推奨します。
Julia 1.6より前のバージョンでは、Windows上のファイルシステムACLを正しく調べられなかったため、どのファイルに対してもtrueを返していました。Julia 1.6以降では、ファイルに実行可能属性が設定されているかどうかを正しく判定します。
ispath、isreadable、iswritableも参照してください。
Base.Sys.isreadable — Function
isreadable(io)::Bool指定された IO オブジェクトが読み取り可能でない場合は、false を返します。
Examples
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")isreadable(path::String)指定されたpathのアクセス権限で現在のユーザーによる読み取りが許可されている場合、trueを返します。
ユーザーがopenを呼び出す前に、この権限が変更される可能性があります。そのため、まずisreadableを呼び出すよりも、openだけを呼び出し、失敗した場合はエラーを処理することを推奨します。
関連項目:ispath、isexecutable、iswritable。
Base.Sys.iswritable — Function
iswritable(io)::Bool指定された IO オブジェクトが書き込み可能でない場合は、false を返します。
Examples
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")iswritable(path::String)指定されたpathへのアクセス権限で現在のユーザーによる書き込みが許可されている場合、trueを返します。
ユーザーがopenを呼び出す前に、この権限が変更される可能性があります。そのため、まずiswritableを呼び出すのではなく、openだけを呼び出し、失敗した場合はエラーを処理することをお勧めします。
関連項目: ispath、isexecutable、isreadable。
Base.Sys.which — Function
Sys.which(program_name::String)プログラム名を指定すると、現在の PATH を検索し、実行権限が適切に設定されていて実行可能な最初のバイナリを見つけて、その絶対パスを返します。そのようなプログラムが見つからない場合は、nothing を返します。program_name にディレクトリを含むパスを指定した場合は、そのパス自体について実行権限のみを確認します(Windows プラットフォームでは .exe と .com の拡張子を追加して確認します)。PATH の検索は行いません。
Base.Sys.username — Function
Sys.username()::String現在のユーザー名を返します。ユーザー名を特定できない場合、または空の場合、この関数はエラーをスローします。
環境変数で上書きできるユーザー名を取得するには、たとえば USER を使用してください。
user = get(Sys.username, ENV, "USER")関連項目: homedir。
Base.@static — Macro
@staticマクロ展開時に式を部分評価します。
これは、OS依存の関数を呼び出すccallや、インポートされていないパッケージで定義されたマクロなど、場合によっては無効になる構文を扱う際に便利です。
@staticには条件式が必要です。条件式は、if文、三項演算子、または&&||のいずれかに記述できます。条件式は、マクロを再帰的に展開し、生成された式をloweringして実行することで評価されます。その後、一致する分岐(あれば)が返されます。条件式のその他の分岐は、マクロ展開(およびloweringや実行)される前に削除されます。
Example
macOSでのみ有効な式exprを解析したいとします。この問題は、@staticと@static if Sys.isapple() expr endを使って解決できます。macOS向けのexpr_appleと、その他のOS向けのexpr_othersがある場合、@staticを使った解決方法は@static Sys.isapple() ? expr_apple : expr_othersとなります。
Versioning
Base.VersionNumber — Type
VersionNumbersemantic versioning (semver)の仕様に従うバージョン番号型です。メジャー、マイナー、パッチの数値に続いて、プレリリースおよびビルドを示す英数字の注釈で構成されます。
VersionNumberオブジェクトは、標準の比較演算子(==、<、<=など)で比較できます。比較結果はsemver v2.0.0-rc.2の規則に従います。
VersionNumberには、次のパブリックフィールドがあります。
v.major::Integerv.minor::Integerv.patch::Integerv.prerelease::Tuple{Vararg{Union{Integer, AbstractString}}}v.build::Tuple{Vararg{Union{Integer, AbstractString}}}
semver形式のリテラル文字列からVersionNumberオブジェクトを効率よく構築するには@v_strを、Julia自体のVersionNumberについてはVERSIONを、マニュアルについてはVersion Number Literalsを参照してください。
Examples
julia> a = VersionNumber(1, 2, 3)
v"1.2.3"
julia> a >= v"1.2"
true
julia> b = VersionNumber("2.0.1-rc1")
v"2.0.1-rc1"
julia> b >= v"2.0.1"
falseBase.@v_str — Macro
@v_str文字列を解析してVersionNumberに変換する文字列マクロ。
Examples
julia> v"1.2.3"
v"1.2.3"
julia> v"2.0.1-rc1"
v"2.0.1-rc1"Errors
Base.error — Function
error(msg...)ErrorExceptionを、string(msg...)で構成したメッセージとともに発生させます。
error(message::AbstractString)指定したメッセージでErrorExceptionを発生させます。
Core.throw — Function
Base.rethrow — Function
rethrow()catch ブロック内で、現在の例外を再スローします。再スローされた例外は、捕捉されなかった場合と同様に伝播を続けます。
もう一つの形式である rethrow(e) を使うと、現在のバックトレースに別の例外オブジェクト e を関連付けられます。ただし、これはエラー発生時のプログラムの状態を正しく表さないため、代わりに throw(e) を使って新しい例外をスローすることをお勧めします。Julia 1.1 以降では、throw(e) を使うと、current_exceptions で説明されているように、根本原因となった例外がスタック上に保持されます。
Base.backtrace — Function
backtrace()現在のプログラム位置のバックトレースオブジェクトを取得します。
Base.catch_backtrace — Function
catch_backtrace()現在の例外のバックトレースを取得します。catch ブロック内で使用します。
Base.current_exceptions — Function
current_exceptions(task::Task=current_task(); [backtrace::Bool=true])現在処理中の例外スタックを取得します。入れ子になった catch ブロックでは、現在の例外が複数存在する場合があります。その場合、最後にスローされた例外がスタックの末尾にあります。スタックは、名前付きタプル (exception,backtrace) の AbstractVector である ExceptionStack として返されます。backtrace が false の場合、各ペアのバックトレースは nothing に設定されます。
task を明示的に渡すと、任意のタスクの現在の例外スタックを取得できます。これは、捕捉されない例外によって失敗したタスクを調べるのに便利です。
Base.@assert — Macro
@assert cond [text]AssertionError を使うと、cond が false の場合に例外をスローします。これはアサーションを記述するための推奨構文です。アサーションとは、真であると想定される条件のことで、失敗した場合にデバッグの助けとしてユーザーが確認できます。省略可能なメッセージ text は、アサーションが失敗したときに表示されます。
最適化レベルによっては、アサーションが無効になることがあります。そのため、アサーションはデバッグ用のツールとしてのみ使用し、認証の検証(パスワードの確認や配列の境界チェックなど)には使用しないでください。関数が正しく動作するために、cond の実行による副作用に依存してはなりません。
Examples
julia> @assert iseven(3) "3 is an odd number!"
ERROR: AssertionError: 3 is an odd number!
julia> @assert isodd(3) "What even are numbers?"Base.Experimental.register_error_hint — Function
Experimental.register_error_hint(handler, exceptiontype)ユーザーがエラーを回避するための方法を提案できる「ヒント」関数 handler(io, exception) を登録します。handler は exception を調べ、ヒントを提示する条件が満たされているかを確認します。条件が満たされていれば、io に出力を生成します。パッケージでは、__init__ 関数内から register_error_hint を呼び出してください。
特定の例外型では、handler が追加の引数を受け取る必要があります。
MethodError: 結合された引数を位置引数とキーワード引数に分割するhandler(io, exc::MethodError, argtypes, kwargs)を指定します。
ヒントを出力する際は、通常、\n で始めます。
独自の例外型を定義する場合、showerror メソッドで Experimental.show_error_hints を呼び出すと、ヒントに対応できます。
Examples
julia> module Hinter
only_int(x::Int) = 1
any_number(x::Number) = 2
function __init__()
Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
if exc.f == only_int
# Color is not necessary, this is just to show it's possible.
print(io, "\nDid you mean to call ")
printstyled(io, "`any_number`?", color=:cyan)
end
end
end
endその後、Int ではないものに対して Hinter.only_int を呼び出すと(MethodError が発生します)、次のヒントが表示されます。
julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
The function `only_int` exists, but no method is defined for this combination of argument types.
Did you mean to call `any_number`?
Closest candidates are:
...Base.Experimental.show_error_hints — Function
Experimental.show_error_hints(io, ex, args...)特定の例外型 typeof(ex) とそのすべてのスーパータイプについて、Experimental.register_error_hint のすべてのハンドラーを呼び出します。args には、その型のハンドラーが必要とするその他の引数をすべて指定してください。
Core.ArgumentError — Type
ArgumentError(msg)関数に渡された引数が無効です。msg は、エラーの内容を説明するメッセージです。
Core.AssertionError — Type
AssertionError([msg])アサートされた条件の評価結果が true ではありませんでした。省略可能な引数 msg は、エラーを説明する文字列です。
Examples
julia> @assert false "this is not true"
ERROR: AssertionError: this is not trueAssertionError は通常、@assert からスローされます。
Core.BoundsError — Type
BoundsError([a],[i])配列へのインデックス操作で、a、範囲外のインデックス i にある要素にアクセスしようとしました。
Examples
julia> A = fill(1.0, 7);
julia> A[8]
ERROR: BoundsError: attempt to access 7-element Vector{Float64} at index [8]
julia> B = fill(1.0, (2,3));
julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [2, 4]
julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [9]
Base.CompositeException — Type
CompositeExceptionTask が投げた例外(たとえば、チャネル経由でリモートワーカーから送られた例外や、非同期で実行されるローカル I/O 書き込み、または pmap 上のリモートワーカーから送られた例外)を Vector でラップし、一連の例外に関する情報を付加します。たとえば、複数のワーカーがいくつかのタスクを実行していて、そのうち複数のワーカーで失敗が発生した場合、結果として得られる CompositeException には、例外がどこで、なぜ発生したかを示す各ワーカーからの情報が「束ねられて」含まれます。
Base.DimensionMismatch — Type
DimensionMismatch([msg])呼び出されたオブジェクトの次元が一致していません。省略可能な引数 msg は、エラーを説明する文字列です。
Core.DivideError — Type
DivideError()分母の値が 0 の状態で整数除算が試みられました。
Examples
julia> 2/0
Inf
julia> div(2, 0)
ERROR: DivideError: integer division error
Stacktrace:
[...]Core.DomainError — Type
DomainError(val)
DomainError(val, msg)関数またはコンストラクターに渡された引数 val は、有効な定義域の範囲外です。
Examples
julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]Base.EOFError — Type
EOFError()ファイルまたはストリームから読み取れるデータはこれ以上ありませんでした。
Core.ErrorException — Type
ErrorException(msg)汎用エラー型です。.msgフィールドのエラーメッセージに、より詳しい情報が記載されている場合があります。
Examples
julia> ex = ErrorException("I've done a bad thing");
julia> ex.msg
"I've done a bad thing"Core.FieldError — Type
FieldError(type::DataType, field::Symbol)オブジェクト type の無効な field にアクセスしようとしました。
Julia 1.12 より前のバージョンでは、無効なフィールドへのアクセス時に ErrorException がスローされていました。
getfield を参照してください。
Examples
julia> struct AB
a::Float32
b::Float64
end
julia> ab = AB(1, 3)
AB(1.0f0, 3.0)
julia> ab.c # field `c` doesn't exist
ERROR: FieldError: type AB has no field `c`, available fields: `a`, `b`
Stacktrace:
[...]Core.InexactError — Type
InexactError(name::Symbol, T, val)関数 name のメソッド内で、val を型 T に正確に変換できません。
Examples
julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]Core.InterruptException — Type
InterruptException()ターミナルからの割り込み(CTRL+C)によって、プロセスが停止しました。
-i(対話モード)を指定せずに起動したJuliaスクリプトでは、デフォルトでInterruptExceptionはスローされません。スクリプト内でBase.exit_on_sigint(false)を呼び出すと、REPLと同じ動作に戻せます。あるいは、Juliaスクリプトを次のように起動すると、
julia -e "include(popfirst!(ARGS))" script.jl実行中にCTRL+Cを押したときにInterruptExceptionがスローされます。
Base.KeyError — Type
KeyError(key)AbstractDict(Dict)やSetのようなオブジェクトに対するインデックス操作で、存在しない要素にアクセスまたは削除しようとしました。
Core.LoadError — Type
LoadError(file::AbstractString, line::Int, error)ファイルのinclude、require、またはusing中にエラーが発生しました。エラーの詳細は.errorフィールドに記載されています。
Core.MethodError — Type
MethodError(f, args)指定されたジェネリック関数に、要求された型シグネチャを持つメソッドが存在しません。または、最も具体的なメソッドが一意に定まりません。
Base.MissingException — Type
MissingException(msg)サポートされていない状況でmissingの値が検出されたときにスローされる例外です。msgフィールドのエラーメッセージに、より詳しい情報が記載されている場合があります。
Core.OutOfMemoryError — Type
OutOfMemoryError()システムまたはガベージコレクターが適切に処理できる量を超えるメモリを、操作によって割り当てました。
Core.ReadOnlyMemoryError — Type
ReadOnlyMemoryError()読み取り専用のメモリに書き込もうとしました。
Core.OverflowError — Type
OverflowError(msg)式の結果が指定された型で表現できる範囲を超えているため、オーバーフローが発生します。
Base.ProcessFailedException — Type
ProcessFailedExceptionプロセスの終了ステータスに問題があることを示します。コマンドやパイプラインの実行時に、ゼロ以外の終了コードが返された(つまり、呼び出したプロセスが失敗した)ことを示すためにスローされます。
Base.TaskFailedException — Type
TaskFailedExceptionこの例外は、タスク t が失敗したときに、wait(t) の呼び出しによってスローされます。TaskFailedException は、失敗したタスク t をラップします。
Core.StackOverflowError — Type
StackOverflowError()関数呼び出しがコールスタックのサイズを超えました。通常、これは呼び出しが無限に再帰している場合に発生します。
Base.SystemError — Type
SystemError(prefix::AbstractString, [errno::Int32])システムコールがエラーコードで失敗しました(errno グローバル変数内)。
Core.TypeError — Type
TypeError(func::Symbol, context::AbstractString, expected::Type, got)型アサーションの失敗、または不正な型の引数を指定して組み込み関数を呼び出した場合。
Core.UndefKeywordError — Type
UndefKeywordError(var::Symbol)関数呼び出しで、必須のキーワード引数 var が指定されていません。
Examples
julia> function my_func(;my_arg)
return my_arg + 1
end
my_func (generic function with 1 method)
julia> my_func()
ERROR: UndefKeywordError: keyword argument `my_arg` not assigned
Stacktrace:
[1] my_func() at ./REPL[1]:2
[2] top-level scope at REPL[2]:1Core.UndefRefError — Type
UndefRefError()指定されたオブジェクトに対して、この項目またはフィールドは定義されていません。
Examples
julia> struct MyType
a::Vector{Int}
MyType() = new()
end
julia> A = MyType()
MyType(#undef)
julia> A.a
ERROR: UndefRefError: access to undefined reference
Stacktrace:
[...]Core.UndefVarError — Type
UndefVarError(var::Symbol, [scope])現在のスコープでシンボルが定義されていません。
Examples
julia> a
ERROR: UndefVarError: `a` not defined in `Main`
julia> a = 1;
julia> a
1Base.StringIndexError — Type
StringIndexError(str, i)無効なインデックス i で str にアクセスしようとしたときにエラーが発生しました。
Core.InitError — Type
InitError(mod::Symbol, error)モジュールの__init__関数の実行中にエラーが発生しました。実際に発生したエラーは、.errorフィールドで確認できます。
Base.retry — Function
retry(f; delays=ExponentialBackOff(), check=nothing) -> Functionf 関数を呼び出す無名関数を返します。例外が発生した場合、check が true を返すたびに、delays で指定された秒数だけ待機してから、f が繰り返し再度呼び出されます。check は、delays の現在の状態と Exception を入力として受け取ります。
Examples
retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, IOError))(io, 128; all=false)Base.ExponentialBackOff — Type
ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)要素が factor * (1 ± jitter) の範囲の割合で指数的に増加する、長さ n の Float64 イテレータ。最初の要素は first_delay で、すべての要素は max_delay に制限されます。
Events
Base.Timer — Method
Timer(callback::Function, delay; interval = 0, spawn::Union{Nothing,Bool}=nothing)タイマーが満了するたびに関数 callback を実行するタイマーを作成します。
最初に delay 秒待った後、待機中のタスクが起こされ、関数 callback が呼び出されます。その後は、秒単位で指定された interval の間隔でこれを繰り返します。interval が 0 と等しい場合、コールバックは一度だけ実行されます。関数 callback は、タイマー自体を唯一の引数として呼び出されます。タイマーを停止するには close を呼び出します。ただし、タイマーがすでに満了している場合は、callback が最後にもう一度実行されることがあります。
spawn が true の場合、作成されたタスクは spawn されます。つまり、スレッド間の移動が許可されるため、親タスクが現在のスレッドに固定されてしまう副作用を回避できます。spawn が nothing(デフォルト)の場合、親タスクが sticky でなければ、タスクは spawn されます。
Examples
ここでは、2 秒待ってから最初の数値が表示され、その後の数値はすぐに続けて表示されます。
julia> begin
i = 0
cb(timer) = (global i += 1; println(i))
t = Timer(cb, 2, interval=0.2)
wait(t)
sleep(0.5)
close(t)
end
1
2
3Base.Timer — Type
Timer(delay; interval = 0)タイマーを作成すると、それを待機しているタスクを起こせます(タイマーオブジェクトに対して wait を呼び出します)。
待機中のタスクは、最初に delay 秒以上経過した後に起こされます。その後は、さらに interval 秒以上経過するたびに起こされます。interval が 0 と等しい場合、タイマーは一度だけ発火します。タイマーを閉じると(close を呼び出すと)、待機中のタスクはエラーによって起こされます。タイマーがまだアクティブかどうかを確認するには、isopen を使用します。非アクティブなタイマーは発火しません。t.timeout と t.interval を使用すると、Timer t の設定条件を読み取れます。
julia> t = Timer(1.0; interval=0.5)
Timer (open, timeout: 1.0 s, interval: 0.5 s) @0x000000010f4e6e90
julia> isopen(t)
true
julia> t.timeout
1.0
julia> close(t)
julia> isopen(t)
falseinterval では、時間のずれが累積することがあります。特定の絶対時刻に正確なイベントを発生させる必要がある場合は、各回の期限が来るたびに、次の時刻までの差分を計算して新しいタイマーを作成してください。
Timer の状態を更新するには、yield ポイントが必要です。たとえば、yield しない while ループのタイムアウトに isopen(t::Timer) を使用することはできません。
!!! compat "Julia 1.12 timeout と interval の読み取り可能なプロパティは、Julia 1.12 で追加されました。
Base.AsyncCondition — Type
AsyncCondition()Cからuv_async_sendを呼び出して通知すると、待機中のタスクを起こす非同期条件を作成します(オブジェクトに対してwaitを呼び出します)。オブジェクトを閉じると(closeを呼び出すと)、待機中のタスクはエラーで起こされます。引き続き有効かどうかはisopenで確認できます。閉じられた条件は無効となり、タスクを起こしません。
これにより、送信側スレッドと待機側スレッドの間に、暗黙的な acquire/release メモリ順序が確立されます。
Base.AsyncCondition — Method
AsyncCondition(callback::Function)指定されたcallback関数を呼び出す非同期条件を作成します。callbackには、非同期条件オブジェクト自体が引数として1つ渡されます。
Reflection
Base.nameof — Method
nameof(m::Module)::SymbolModule の名前を Symbol として取得します。
Examples
julia> nameof(Base.Broadcast)
:BroadcastBase.parentmodule — Function
parentmodule(m::Method)::Module指定したメソッド m が定義されているモジュールを返します。
parentmodule(f::Function, types)::Module指定されたtypesに一致する、ジェネリック関数fの最初のメソッドを含むモジュールを特定します。
parentmodule(f::Function)::Moduleジェネリック関数の(最初の)定義を含むモジュールを特定します。
parentmodule(t::DataType)::Module(UnionAllで囲まれている可能性のある)DataTypeの定義を含むモジュールを特定します。
Examples
julia> module Foo
struct Int end
end
Foo
julia> parentmodule(Int)
Core
julia> parentmodule(Foo.Int)
Fooparentmodule(m::Module)::Moduleモジュールを囲むModuleを取得します。Mainは、それ自体が親です。
関連項目: names、nameof、fullname、@__MODULE__。
Examples
julia> parentmodule(Main)
Main
julia> parentmodule(Base.Broadcast)
BaseBase.pathof — Method
pathof(m::Module)m.jl ファイルのパスを返します。このファイルは import モジュール m の読み込みに使用されたものです。m がパッケージからインポートされていない場合は、nothing を返します。
パスのディレクトリ部分を取得するには dirname を、ファイル名部分を取得するには basename を使用してください。
pkgdir も参照してください。
Base.pkgdir — Method
pkgdir(m::Module[, paths::String...])モジュール m を宣言したパッケージのルートディレクトリを返します。m がパッケージ内で宣言されていない場合は、nothing を返します。パッケージのルート内のパスを構築するために、追加のパス要素文字列を指定することもできます。
現在のモジュールを実装するパッケージのルートディレクトリを取得するには、pkgdir(@__MODULE__) の形式を使用できます。
拡張モジュールを指定した場合は、親パッケージのルートが返されます。
julia> pkgdir(Foo)
"/path/to/Foo.jl"
julia> pkgdir(Foo, "src", "file.jl")
"/path/to/Foo.jl/src/file.jl"関連項目: pathof。
Base.pkgversion — Method
pkgversion(m::Module)モジュール m がバージョン管理されたパッケージに属している場合は、そのパッケージのバージョン番号を返します。そうでない場合は、nothing を返します。
バージョンは、パッケージの読み込み時に、そのパッケージの Project.toml から読み取られます。
現在のモジュールをインポートしたパッケージのバージョンを取得するには、pkgversion(@__MODULE__) という形式を使用できます。
Base.moduleroot — Function
moduleroot(m::Module)::Module指定されたモジュールのルートモジュールを検索します。これは、m の親モジュールをたどったときに、登録済みのルートモジュールであるか、自身を親モジュールとする最初のモジュールです。
__module__ — Keyword
__module__引数 __module__ はマクロ内でのみ参照でき、マクロ呼び出しの展開コンテキストに関する情報を(Module オブジェクトの形式で)提供します。詳しくは、Macro invocation のマニュアルの節を参照してください。
__source__ — Keyword
__source__引数 __source__ はマクロ内でのみ参照でき、マクロ呼び出しにおける @ 記号のパーサー上の位置に関する情報を、LineNumberNode オブジェクトとして提供します。詳しくは、マニュアルの Macro invocation の節を参照してください。
Base.@__MODULE__ — Macro
@__MODULE__ -> Moduleトップレベルの評価で使用されているModuleを取得します。これは、現在コードを読み込んでいるModuleです。
Base.@__FUNCTION__ — Macro
@__FUNCTION__最も内側で囲んでいる関数オブジェクトを取得します。
Examples
@__FUNCTION__を使うと、再帰的な無名関数を定義できます。
julia> factorial = (n -> n <= 1 ? 1 : n * (@__FUNCTION__)(n - 1));
julia> factorial(5)
120@__FUNCTION__はnameofと組み合わせることで、関数本体の中から関数名を特定できます。
julia> bar() = nameof(@__FUNCTION__);
julia> bar()
:barBase.@__FILE__ — Macro
@__FILE__ -> Stringマクロ呼び出しを含むファイルへのパスを文字列として展開します。julia -e <expr>によって評価された場合は、空文字列を返します。マクロにパーサーのソース情報がなかった場合は、nothingを返します。あるいは、PROGRAM_FILEを参照してください。
Base.@__DIR__ — Macro
@__DIR__ -> String現在のディレクトリの絶対パスを文字列として取得するマクロ。
スクリプト内で使用した場合は、@__DIR__ マクロ呼び出しを含むスクリプトのディレクトリを返します。REPL から実行した場合、または julia -e <expr> によって評価された場合は、現在の作業ディレクトリを返します。
Examples
この例では、現在の作業ディレクトリとは異なるディレクトリに簡単なスクリプトを作成し、両方のコマンドを実行することで、@__DIR__ と pwd() の動作の違いを示します。
julia> cd("/home/JuliaUser") # working directory
julia> # create script at /home/JuliaUser/Projects
open("/home/JuliaUser/Projects/test.jl","w") do io
print(io, """
println("@__DIR__ = ", @__DIR__)
println("pwd() = ", pwd())
""")
end
julia> # outputs script directory and current working directory
include("/home/JuliaUser/Projects/test.jl")
@__DIR__ = /home/JuliaUser/Projects
pwd() = /home/JuliaUserBase.@__LINE__ — Macro
@__LINE__ -> Intマクロ呼び出しがある位置の行番号に展開します。行番号を特定できない場合は、0を返します。
Base.fullname — Function
fullname(m::Module)モジュールの完全修飾名をシンボルのタプルとして取得します。たとえば、
Examples
julia> fullname(Base.Iterators)
(:Base, :Iterators)
julia> fullname(Main)
(:Main,)Base.names — Function
names(x::Module; all::Bool=false, imported::Bool=false, usings::Bool=false, world::UInt=Base.tls_world_age())::Vector{Symbol}Module の公開名を、非推奨の名前を除いてベクトルとして取得します。all が true の場合、モジュール内で定義された非公開名、非推奨の名前、コンパイラが生成した名前もリストに含まれます。imported が true の場合、他のモジュールから明示的にインポートされた名前も含まれます。usings が true の場合、using を介して明示的または暗黙的にインポートされた名前も含まれます。名前はソートされた順序で返されます。
特例として、Main で定義された名前はすべて「公開」とみなされます。Main の名前を明示的に公開指定するのは、慣用的ではないためです。
world 引数は、バインディングのパーティションを検索する際に使用するワールドエイジを指定します。デフォルトは現在のタスクのワールドエイジです。最新のワールドにある名前を含めるには、world=Base.get_world_counter() を渡します。
sym ∈ names(SomeModule) は isdefined(SomeModule, sym) を意味するものではありません。names は、モジュール内で定義されていなくても、public または export としてマークされたシンボルを返すことがあります。
関連項目: Base.isexported、Base.ispublic、Base.@locals、@__MODULE__。
Base.isexported — Function
isexported(m::Module, s::Symbol)::Boolシンボルがモジュールからエクスポートされているかどうかを返します。
julia> module Mod
export foo
public bar
end
Mod
julia> Base.isexported(Mod, :foo)
true
julia> Base.isexported(Mod, :bar)
false
julia> Base.isexported(Mod, :baz)
falseBase.ispublic — Function
ispublic(m::Module, s::Symbol)::Boolシンボルがモジュール内で public としてマークされているかどうかを返します。
エクスポートされたシンボルは public とみなされます。
関連項目: isexported, names
julia> module Mod
export foo
public bar
end
Mod
julia> Base.ispublic(Mod, :foo)
true
julia> Base.ispublic(Mod, :bar)
true
julia> Base.ispublic(Mod, :baz)
falseBase.nameof — Method
nameof(f::Function)::SymbolジェネリックなFunctionの名前をシンボルとして取得します。無名関数の場合、これはコンパイラーが生成した名前です。Functionの明示的に宣言されたサブタイプの場合、これは関数の型の名前です。
Base.functionloc — Method
functionloc(f::Function, types)ジェネリックな Function の定義位置を示すタプル (filename,line) を返します。
Base.functionloc — Method
functionloc(m::Method)(filename,line) を返します。これは Method 定義の位置を示すタプルです。
Base.@locals — Macro
@locals()呼び出し位置で定義されているすべてのローカル変数について、名前(シンボル)と値を対応付けた辞書を構築します。
Examples
julia> let x = 1, y = 2
Base.@locals
end
Dict{Symbol, Any} with 2 entries:
:y => 2
:x => 1
julia> function f(x)
local y
show(Base.@locals); println()
for i = 1:1
show(Base.@locals); println()
end
y = 2
show(Base.@locals); println()
nothing
end;
julia> f(42)
Dict{Symbol, Any}(:x => 42)
Dict{Symbol, Any}(:i => 1, :x => 42)
Dict{Symbol, Any}(:y => 2, :x => 42)Core.getglobal — Function
getglobal(module::Module, name::Symbol, [order::Symbol=:monotonic])モジュール module から、束縛 name の値を取得します。この操作にはアトミック順序を任意で指定できます。指定しない場合、デフォルトは monotonic です。
互換性を維持するため、getfield によるモジュールの束縛へのアクセスも引き続きサポートされていますが、常に getglobal を優先して使用すべきです。getglobal ではアトミック順序を制御でき(getfield は常に monotonic)、ユーザーにもコンパイラにもコードの意図がより明確に伝わるためです。
ほとんどのユーザーは、この関数を直接呼び出す必要はありません。ごく少数の非常に限定的なユースケースを除き、getproperty 関数または対応する構文(module.name)を優先して使用すべきです。
getproperty および setglobal! も参照してください。
Examples
julia> a = 1
1
julia> module M
a = 2
end;
julia> getglobal(@__MODULE__, :a)
1
julia> getglobal(M, :a)
2Core.setglobal! — Function
setglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])モジュール module 内の束縛 name の値を x に設定または変更します。型変換は行われないため、束縛にすでに型が宣言されている場合、x は適切な型でなければならず、そうでない場合はエラーが発生します。
この操作では、アトミック順序を指定することもできます。指定しない場合は、デフォルトで monotonic になります。
通常、ユーザーは setproperty! 関数または対応する構文(つまり module.name = x)を通じてこの機能を利用するため、これは非常に限定的な用途を想定しています。
関連項目: setproperty! および getglobal
Examples
julia> module M; global a; end;
julia> M.a # same as `getglobal(M, :a)`
ERROR: UndefVarError: `a` not defined in `M`
Suggestion: add an appropriate import or assignment. This global was declared but not assigned.
Stacktrace:
[1] getproperty(x::Module, f::Symbol)
@ Base ./Base_compiler.jl:40
[2] top-level scope
@ none:1
julia> setglobal!(M, :a, 1)
1
julia> M.a
1Core.modifyglobal! — Function
modifyglobal!(module::Module, name::Symbol, op, x, [order::Symbol=:monotonic])::Pair関数 op を適用した後、グローバル変数の取得と設定をアトミックに実行します。
modifyproperty! および setglobal! も参照してください。
Core.swapglobal! — Function
swapglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])グローバル変数の取得と設定を同時に、アトミックに実行します。
関連項目: swapproperty!、setglobal!。
Core.setglobalonce! — Function
setglobalonce!(module::Module, name::Symbol, value,
[success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Boolグローバル変数がまだ設定されていない場合に限り、指定した値を設定する操作をアトミックに実行します。
関連項目: setpropertyonce!、setglobal!。
Core.replaceglobal! — Function
replaceglobal!(module::Module, name::Symbol, expected, desired,
[success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)グローバル変数の値を取得し、条件を満たす場合に指定した値へ設定する操作をアトミックに実行します。
関連項目: replaceproperty!、setglobal!。
Core.declare_const — Function
declare_const(module::Module, name::Symbol, [x])module 内の定数 name を、新しい値 x で作成または置き換えます。置き換える場合、x は元の定数と同じ型である必要はありません。
x が指定されていない場合、name は未定義の定数になります。読み書きはできませんが、再定義は可能です。
const という構文とは異なり、この関数を呼び出しても、現在のフレームのワールドエイジを更新するための Core.@latestworld は挿入されません。
julia> begin
const x = 1
println(x)
const x = 2
println(x)
Core.declare_const(Main, :x, 3)
println(x)
Core.@latestworld
println(x)
end
1
2
2
3関連項目: const。
Documentation
(documentationの章も参照してください。)
Core.@doc — Macro
Documentation
関数、メソッド、型は、定義の前に文字列を置くことでドキュメント化できます。
"""
foo(x)
Return a fooified version of `x`.
"""
foo(x) = ...@doc マクロを直接使うと、ドキュメントやメタデータの設定と取得の両方を行えます。このマクロには特殊な構文解析機能があり、ドキュメント化するオブジェクトを次の行に記述できます。
@doc "blah"
function foo() ...デフォルトではドキュメントは Markdown で記述しますが、最初の引数には任意のオブジェクトを指定できます。
Documenting objects separately from their definitions
オブジェクトの定義の前後どちらでも、次のようにドキュメントを記述できます。
@doc "foo" function_to_doc
@doc "bar" TypeToDocマクロの場合、構文は @doc "macro doc" :(Module.@macro) です。文字列マクロでは @doc "macro doc" :(string_macro"") を使います。クォート :() を付けない場合、マクロの展開結果がドキュメント化されます。
Retrieving Documentation
関数、マクロ、その他のオブジェクトのドキュメントは、次のように取得できます。
@doc foo
@doc @time
@doc md""Functions & Methods
メソッド定義(例: function foo() ... や foo() = ...)の前にドキュメントを置くと、関数全体ではなく、その特定のメソッドがドキュメント化されます。関数のドキュメントを構成するため、各メソッドのドキュメントは定義された順に連結されます。
Base.Docs.HTML — Type
HTML(s): s を HTML としてレンダリングするオブジェクトを作成します。
HTML("<div>foo</div>")大量のデータを扱う場合は、ストリームも使用できます。
HTML() do io
println(io, "<div>foo</div>")
endHTML は後方互換性を維持するため現在もエクスポートされていますが、このエクスポートは非推奨です。この型は Docs.HTML として使用するか、Docs から明示的にインポートすることを推奨します。
Base.Docs.Text — Type
Text(s): sをプレーンテキストとして出力するオブジェクトを作成します。
Text("foo")大量のデータを扱う場合は、ストリームも使用できます。
Text() do io
println(io, "foo")
endTextは後方互換性を維持するため現在もエクスポートされていますが、このエクスポートは非推奨です。この型はDocs.Textとして使用するか、Docsから明示的にインポートすることを推奨します。
Base.Docs.hasdoc — Function
Docs.hasdoc(mod::Module, sym::Symbol)::Booltrue を返します。ただし、mod 内の sym に docstring がある場合は false を返します。
Base.Docs.undocumented_names — Function
undocumented_names(mod::Module; private=false)module 内のドキュメント化されていないシンボル(docstring がないシンボル)を、ソート済みのベクトルとして返します。private=false(デフォルト)は、public および/または export で宣言された識別子のみを返します。一方、private=true は、モジュール内のすべてのシンボルを返します(# で始まる、コンパイラが生成した非表示シンボルは除きます)。
関連項目:names、Docs.hasdoc、Base.ispublic。
Code loading
Base.identify_package — Function
Base.identify_package(name::String)::Union{PkgId, Nothing}
Base.identify_package(where::Union{Module,PkgId}, name::String)::Union{PkgId, Nothing}現在の環境スタックから名前でパッケージを特定し、そのPkgIdを返します。見つからない場合はnothingを返します。
name引数だけが指定された場合、スタック内の各環境と、その環境に名前付きで直接依存するパッケージを検索します。
where引数は、パッケージの検索元となるコンテキストを指定します。この場合、まず名前がコンテキスト自体と一致するかを確認します。一致しなければ、各環境の解決済みマニフェストに記載されたすべての再帰的な依存関係を検索し、コンテキストwhereを見つけます。そこから、対応する名前の依存パッケージを特定します。
julia> Base.identify_package("Pkg") # Pkg is a dependency of the default environment
Pkg [44cfe95a-1eb2-52ea-b672-e2afdf69b78f]
julia> using LinearAlgebra
julia> Base.identify_package(LinearAlgebra, "Pkg") # Pkg is not a dependency of LinearAlgebraBase.locate_package — Function
Base.locate_package(pkg::PkgId)::Union{String, Nothing}識別子 pkg に対応するパッケージのエントリーポイントファイルへのパス。見つからない場合は nothing。詳しくは identify_package も参照してください。
julia> pkg = Base.identify_package("Pkg")
Pkg [44cfe95a-1eb2-52ea-b672-e2afdf69b78f]
julia> Base.locate_package(pkg)
"/path/to/julia/stdlib/v1.13/Pkg/src/Pkg.jl"Base.require — Function
require(into::Module, module::Symbol)この関数は、Main でモジュールがまだ定義されていない場合に、using / import を実装するために使われます。また、モジュールが以前に読み込まれているかどうかにかかわらず、強制的に再読み込みするために直接呼び出すこともできます(たとえば、ライブラリを対話的に開発する場合)。
Main モジュールのコンテキストでソースファイルを読み込み、すべてのアクティブなノード上で標準の場所を検索します。require はトップレベルの操作とみなされるため、現在の include パスを設定しますが、ファイルの検索には使用しません(include のヘルプを参照)。この関数は通常、ライブラリコードの読み込みに使われ、パッケージを読み込むために using から暗黙的に呼び出されます。
ファイルを検索する際、require はまず、グローバル配列 LOAD_PATH 内のパッケージコードを探します。require では、macOS や Windows のようにファイルシステムが大文字と小文字を区別しないプラットフォームを含め、すべてのプラットフォームで大文字と小文字が区別されます。
コードの読み込みについて詳しくは、マニュアルの modules および parallel computing の各セクションを参照してください。
Base.compilecache — Function
Base.compilecache(module::PkgId)モジュールとそのすべての依存関係を含む、プリコンパイル済みキャッシュファイルを作成します。これにより、パッケージの読み込み時間を短縮できます。キャッシュファイルはDEPOT_PATH[1]/compiledに保存されます。重要な注意事項については、Module initialization and precompilationを参照してください。
Base.isprecompiled — Function
Base.isprecompiled(pkg::PkgId; ignore_loaded::Bool=false)指定した PkgId がアクティブなプロジェクト内でプリコンパイル済みかどうかを返します。
デフォルトでは、依存関係の異なるバージョンが現在読み込まれている場合の扱いについて、コードの読み込み時と同じ方法で判定します。読み込み済みのモジュールを無視し、新しい Julia セッションであるかのように判定するには、ignore_loaded=true を指定します。
Base.get_extension — Function
get_extension(parent::Module, extension::Symbol)parent の extension モジュールを返します。拡張機能が読み込まれていない場合は、nothing を返します。
Internals
Base.GC.gc — Function
GC.gc([full=true])ガベージコレクションを実行します。引数 full は、コレクションの種類を指定します。デフォルトのフルコレクションでは、すべての生存オブジェクトを走査(つまり、完全なマーク処理)し、到達不能なオブジェクトのメモリをすべて回収します。インクリメンタルコレクションでは、到達不能な若いオブジェクトのメモリのみを回収します。
インクリメンタルコレクションを要求した場合でも、GC がフルコレクションを実行することがあります。
Base.GC.enable — Function
GC.enable(on::Bool)ブール値の引数でガベージコレクションを有効にするかどうかを指定します(有効にする場合はtrue、無効にする場合はfalse)。以前のGCの状態を返します。
Base.GC.@preserve — Macro
GC.@preserve x1 x2 ... xn expr式 expr の評価中、オブジェクト x1, x2, ... を「使用中」としてマークします。これは、expr が x のいずれかが所有するメモリやその他のリソースを暗黙的に使用する、unsafe なコードでのみ必要です。
x の暗黙的な使用とは、コンパイラーからは見えない、x が論理的に所有するリソースの間接的な使用を指します。例を挙げます。
Ptrを介してオブジェクトのメモリに直接アクセスするxへのポインターをccallに渡す- ファイナライザーによってクリーンアップされる
xのリソースを使用する
@preserve は、オブジェクトの寿命を一時的に延長するだけの一般的なユースケースでは、通常、パフォーマンスに影響しません。実装上、@preserve には、動的に割り当てられたオブジェクトがガベージコレクションされないよう保護する効果があります。
Examples
unsafe_load を使ってポインターから読み込む場合、参照先のオブジェクトは暗黙的に使用されます。たとえば、次の例では unsafe_load(p) によって x が暗黙的に使用されます。
julia> let
x = Ref{Int}(101)
p = Base.unsafe_convert(Ptr{Int}, x)
GC.@preserve x unsafe_load(p)
end
101ccall にポインターを渡す場合、ポインターが指すオブジェクトは暗黙的に使用されるため、保持しておく必要があります。ただし通常は、x を ccall に直接渡すだけでかまいません。これは明示的な使用として扱われます。
julia> let
x = "Hello"
p = pointer(x)
Int(GC.@preserve x @ccall strlen(p::Cstring)::Csize_t)
# Preferred alternative
Int(@ccall strlen(x::Cstring)::Csize_t)
end
5Base.GC.safepoint — Function
GC.safepoint()ガベージコレクションが実行される可能性のあるポイントをプログラム内に挿入します。
セーフポイントは高速で、それ自体がガベージコレクションを開始することはありません。ただし、別のスレッドがGCの実行を要求している場合、セーフポイントに到達すると、現在のスレッドはブロックしてGCの完了を待ちます。
これは、マルチスレッドプログラムでまれに役立つことがあります。あるタスクがメモリを割り当てている(そのためGCの実行が必要になる可能性がある)一方で、別のタスクは単純な操作だけを行っている(メモリ割り当て、タスク切り替え、I/Oを行わない)場合です。後者のタスクはJuliaのランタイムに制御を渡さないため、GCの実行を妨げます。メモリを割り当てないタスクでこの関数を定期的に呼び出すと、ガベージコレクションを実行できるようになります。
セーフポイントは高速(通常は約2クロックサイクル)ですが、タイトなループ内で呼び出すとパフォーマンスが低下することがあります。
Base.GC.enable_logging — Function
GC.enable_logging(on::Bool)有効にすると、各 GC に関する統計情報を stderr に出力します。
Base.GC.logging_enabled — Function
GC.logging_enabled()GC.enable_loggingによってGCログが有効化されているかどうかを返します。
Base.Meta.lower — Function
lower(m, x)式 x を受け取り、モジュール m で実行するための、低レベル形式の等価な式を返します。code_lowered も参照してください。
Base.Meta.@lower — Macro
@lower [m] x式 x をモジュール m で展開した形で返します。デフォルトでは、マクロが呼び出されたモジュールが m になります。lower も参照してください。
Base.Meta.parse — Method
parse(str, start; greedy=true, raise=true, depwarn=true, filename="none")式文字列を解析し、式を返します(返された式は、後で実行するために eval に渡すことができます)。start は、解析を開始する最初の文字の str 内でのコード単位インデックスです(文字列のインデックス付けでは、通常どおり文字インデックスではありません)。greedy が true(デフォルト)の場合、parse は可能な限り多くの入力を読み取ろうとします。それ以外の場合は、有効な式を解析した時点で停止します。不完全でも、それ以外は構文的に有効な式の場合、Expr(:incomplete, "(error message)") を返します。raise が true(デフォルト)の場合、不完全な式以外の構文エラーはエラーを発生させます。raise が false の場合、parse は、評価時にエラーを発生させる式を返します。depwarn が false の場合、非推奨警告は抑制されます。エラー発生時に診断情報を表示するには、filename 引数を使用します。
julia> Meta.parse("(α, β) = 3, 5", 1) # start of string
(:((α, β) = (3, 5)), 16)
julia> Meta.parse("(α, β) = 3, 5", 1, greedy=false)
(:((α, β)), 9)
julia> Meta.parse("(α, β) = 3, 5", 16) # end of string
(nothing, 16)
julia> Meta.parse("(α, β) = 3, 5", 11) # index of 3
(:((3, 5)), 16)
julia> Meta.parse("(α, β) = 3, 5", 11, greedy=false)
(3, 13)Base.Meta.parse — Method
parse(str; raise=true, depwarn=true, filename="none")式文字列を貪欲に解析し、単一の式を返します。最初の式の後に文字が残っている場合はエラーが発生します。raise が true(デフォルト)の場合、構文エラーが発生するとエラーになります。それ以外の場合、parse は、評価時にエラーを発生させる式を返します。depwarn が false の場合、非推奨警告は抑制されます。エラー発生時に診断情報を表示するには、filename 引数を使用します。
julia> Meta.parse("x = 3")
:(x = 3)
julia> Meta.parse("1.0.2")
ERROR: ParseError:
# Error @ none:1:1
1.0.2
└──┘ ── invalid numeric constant
[...]
julia> Meta.parse("1.0.2"; raise = false)
:($(Expr(:error, "invalid numeric constant "1.0."")))
julia> Meta.parse("x = ")
:($(Expr(:incomplete, "incomplete: premature end of input")))Base.Meta.ParseError — Type
ParseError(msg)parse 関数に渡された式を、有効な Julia 式として解釈できませんでした。
Core.QuoteNode — Type
QuoteNode補間をサポートしない、引用されたコード片です。詳しくはmanual section about QuoteNodesを参照してください。
Base.macroexpand — Function
macroexpand(m::Module, x; recursive=true, legacyscope=true)式 x を受け取り、すべてのマクロを展開して削除した、モジュール m で実行可能な等価な式を返します。recursive キーワードは、ネストされたマクロをさらに深い階層まで展開するかどうかを制御します。legacyscope キーワードは、従来のマクロスコープ展開を行うかどうかを制御します。以下の例で説明します。
julia> module M
macro m1()
42
end
macro m2()
:(@m1())
end
end
M
julia> macroexpand(M, :(@m2()), recursive=true)
42
julia> macroexpand(M, :(@m2()), recursive=false)
:(#= REPL[1]:6 =# @m1)Base.macroexpand! — Function
macroexpand!(m::Module, x; recursive=true, legacyscope=false)式 x を受け取り、すべてのマクロを展開した同等の式を返します。モジュール m で実行するために、コピーを作成せず x をその場で変更します。recursive キーワードは、ネストしたマクロのより深い階層も展開するかどうかを制御します。legacyscope キーワードは、従来のマクロスコープ展開を行うかどうかを制御します。
この関数は最初のコピー処理を行わずにマクロを展開するため、元の式が不要な場合はより効率的です。必要に応じてマクロスコープ展開を別途実行できるため、その場で展開する場合はデフォルトで無効になっています。
Base.@macroexpand — Macro
@macroexpand [mod,] exすべてのマクロを展開して取り除いた、同等の式を返します。引数を2つ指定した場合、1つ目の引数は評価対象のモジュールです。
@macroexpand と macroexpand には、次の違いがあります。
macroexpandはキーワード引数recursiveを取りますが、@macroexpandは常に再帰的です。再帰しないマクロ版については、@macroexpand1を参照してください。macroexpandには明示的なmodule引数がありますが、@macroexpandは常に、呼び出されたモジュールに対して展開されます。
次の例を見ると、違いがよくわかります。
julia> module M
macro m()
1
end
function f()
(@macroexpand(@m),
macroexpand(M, :(@m)),
macroexpand(parentmodule(M), :(@m))
)
end
end
M
julia> macro m()
2
end
@m (macro with 1 method)
julia> M.f()
(1, 1, 2)@macroexpand では、コード中の @macroexpand の位置(この例ではモジュール M)で式が展開されます。一方、macroexpand では、最初の引数で指定したモジュール内で式が展開されます。
Base.@macroexpand1 — Macro
@macroexpand1 [mod,] ex@macroexpandの非再帰版。
Base.code_lowered — Function
code_lowered(f, types; generated=true, debuginfo=:default)指定されたジェネリック関数と型シグネチャに一致するメソッドの、lowered form(IR)の配列を返します。
generated が false の場合、返される CodeInfo インスタンスはフォールバック実装に対応します。フォールバック実装が存在しない場合はエラーがスローされます。generated が true の場合、これらの CodeInfo インスタンスは、ジェネレーターを展開して得られるメソッド本体に対応します。
キーワード debuginfo は、出力に含まれるコードメタデータの量を制御します。
generated が true であり、対応するメソッドのいずれかが @generated メソッドである場合、types が具象型でなければエラーがスローされることに注意してください。
Base.code_typed — Function
code_typed(f, types; kw...)指定されたジェネリック関数と型シグネチャに一致するメソッドについて、型推論済みの低レベル表現(IR)の配列を返します。
Keyword Arguments
optimize::Bool = true: 省略可能です。インライン化などの追加の最適化も適用するかどうかを制御します。debuginfo::Symbol = :default: 省略可能です。出力に含めるコードメタデータの量を制御します。指定できる値は:sourceまたは:noneです。
Internal Keyword Arguments
このセクションは内部向けであり、Juliaコンパイラの内部実装を理解している人のみを対象としています。
world::UInt = Base.get_world_counter(): 省略可能です。メソッドの検索に使用するワールドエイジを制御します。指定しない場合は、現在のワールドエイジが使用されます。interp::Core.Compiler.AbstractInterpreter = Core.Compiler.NativeInterpreter(world): 省略可能です。使用する抽象インタープリターを制御します。指定しない場合は、ネイティブインタープリターが使用されます。
Examples
引数の型をタプルにまとめると、対応する code_typed を取得できます。
julia> code_typed(+, (Float64, Float64))
1-element Vector{Any}:
CodeInfo(
1 ─ %1 = Base.add_float(x, y)::Float64
└── return %1
) => Float64
julia> code_typed((typeof(-), Float64, Float64))
1-element Vector{Any}:
CodeInfo(
1 ─ %1 = Base.sub_float(x, y)::Float64
└── return %1
) => Float64
julia> code_typed((Type{Int}, UInt8))
1-element Vector{Any}:
CodeInfo(
1 ─ %1 = Core.zext_int(Core.Int64, x)::Int64
└── return %1
) => Int64
julia> code_typed((Returns{Int64},))
1-element Vector{Any}:
CodeInfo(
1 ─ %1 = builtin Base.getfield(obj, :value)::Int64
└── return %1
) => Int64Base.precompile — Function
precompile(f, argtypes::Tuple{Vararg{Any}}, m::Method)指定した引数型に対する特定のメソッドを事前コンパイルします。これにより、通常のディスパッチで選択されるメソッドとは異なるメソッドを事前コンパイルでき、invoke を模倣できます。
precompile(f, argtypes::Tuple{Vararg{Any}})指定された関数 f を、引数タプル(型)argtypes に対してコンパイルします。ただし、実行はしません。
Base.jit_total_bytes — Function
Base.jit_total_bytes()たとえば、ネイティブコードやデータのためにジャストインタイムコンパイラが割り当てた総量(バイト単位)を返します。
Meta
Base.Meta.quot — Function
Meta.quot(ex)::Expr式 ex をクォートすると、ヘッドが quote の式が生成されます。たとえば、AST 内で型 Expr のオブジェクトを表すために使用できます。QuoteNode に関するマニュアルのセクションも参照してください。
Examples
julia> eval(Meta.quot(:x))
:x
julia> dump(Meta.quot(:x))
Expr
head: Symbol quote
args: Array{Any}((1,))
1: Symbol x
julia> eval(Meta.quot(:(1+2)))
:(1 + 2)Base.isexpr — Function
Meta.isexpr(ex, head[, n])::Boolexが指定された型headのExprであり、さらに引数リストの長さがnであることを任意で確認したうえで、trueを返します。headには、SymbolまたはSymbolのコレクションを指定できます。たとえば、マクロに関数呼び出し式が渡されたことを確認するには、isexpr(ex, :call)を使います。
Examples
julia> ex = :(f(x))
:(f(x))
julia> Meta.isexpr(ex, :block)
false
julia> Meta.isexpr(ex, :call)
true
julia> Meta.isexpr(ex, [:block, :call]) # multiple possible heads
true
julia> Meta.isexpr(ex, :call, 1)
false
julia> Meta.isexpr(ex, :call, 2)
trueBase.Meta.isidentifier — Function
isidentifier(s) -> Boolシンボルまたは文字列 s に、Julia コードで有効な通常の識別子(2項演算子または単項演算子ではないもの)として解析される文字が含まれているかどうかを返します。Base.isoperator も参照してください。
Julia の内部では、\0 を除き、Symbol に任意の文字列を使用できます。また、マクロは周囲のコードとの名前の衝突を避けるため、# を含む変数名を自動的に使用します。パーサーが変数を認識するには、限られた文字セット(Unicode によって大幅に拡張されています)が使われます。isidentifier() を使うと、シンボルに有効な文字が含まれているかどうかをパーサーに直接問い合わせられます。
Examples
julia> Meta.isidentifier(:x), Meta.isidentifier("1x")
(true, false)Base.Meta.isoperator — Function
isoperator(s::Symbol)その記号を演算子として使用できる場合は、trueを返し、使用できない場合はfalseを返してください。
Examples
julia> Meta.isoperator(:+), Meta.isoperator(:f)
(true, false)Base.Meta.isunaryoperator — Function
isunaryoperator(s::Symbol)その記号を単項(前置)演算子として使用できる場合は、trueを返します。使用できない場合は、falseを返します。
Examples
julia> Meta.isunaryoperator(:-), Meta.isunaryoperator(:√), Meta.isunaryoperator(:f)
(true, true, false)Base.Meta.isbinaryoperator — Function
isbinaryoperator(s::Symbol)その記号を二項(中置)演算子として使用できる場合は、trueを返します。そうでない場合は、falseを返します。
Examples
julia> Meta.isbinaryoperator(:-), Meta.isbinaryoperator(:√), Meta.isbinaryoperator(:f)
(true, false, false)Base.Meta.show_sexpr — Function
Meta.show_sexpr([io::IO,], ex)式 ex を Lisp 形式の S 式として表示します。
Examples
julia> Meta.show_sexpr(:(f(x, g(y,z))))
(:call, :f, :x, (:call, :g, :y, :z))