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.exit — Function
exit(code=0)

終了コードを指定してプログラムを終了します。デフォルトの終了コードはゼロで、プログラムが正常に完了したことを示します。対話セッションでは、キーボードショートカット ^D を使って exit() を呼び出せます。

source
Base.atexit — Function
atexit(f)

プロセス終了時に呼び出す、引数を取らないか、引数を1つ取る関数 f() を登録します。atexit() フックは後入れ先出し(LIFO)の順序で呼び出され、オブジェクトのファイナライザーより先に実行されます。

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

Julia 1.9

引数を1つ取る形式には Julia 1.9 が必要です。

終了フック内では exit(n) を呼び出せます。この場合、Julia は元の終了コードではなく、終了コード n で終了します。複数の終了フックが exit(n) を呼び出した場合、Julia は exit(n) を呼び出す終了フックのうち、最後に呼び出されたフックに対応する終了コードで終了します。(終了フックは LIFO 順で呼び出されるため、「最後に呼び出された」は「最初に登録された」と同じ意味になります。)

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

source
Base.isinteractive — Function
isinteractive()::Bool

Juliaが対話セッションで実行されているかどうかを判定します。

source
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)
4
source
Base.__precompile__ — Function
__precompile__(isprecompilable::Bool)

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

source
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 です。

Julia 1.5

mapexpr 引数を渡すには、Julia 1.5 が必要です。

source
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を使います。

Note

Juliaの構文降下処理は、トップレベルにあるリテラルincludeへの明示的な呼び出しを認識し、インクルードした定義を後続のコードから参照できるよう、暗黙的な@Core.latestworldを挿入します。ただし、この認識は構文上のものです。つまり、const myinclude = includeを代入する場合は、myincludeの後に明示的な@Core.latestworldの呼び出しが必要になることがあります。

Julia 1.5

mapexpr引数を渡すには、Julia 1.5が必要です。

source
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です。

Julia 1.5

mapexpr引数を渡すには、Julia 1.5が必要です。

source
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 経由では使用されないパスに依存している場合にのみ必要です。コンパイル以外では効果はありません。

Julia 1.11

キーワード引数 track_content を使用するには、Julia 1.11 以降が必要です。path が読み取り可能でない場合、エラーがスローされるようになりました。

source
__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
end
source
Base.OncePerProcess — Type
OncePerProcess{T}(init::Function)() -> T

OncePerProcess オブジェクトを呼び出すと、関数 initializer がプロセスごとにちょうど1回実行され、その戻り値として型 T の値が返されます。同じプロセス内での並行呼び出しも、その後の呼び出しも、すべてまったく同じ値を返します。これは、事前コンパイルされるコードで便利です。シリアライズされないキャッシュやその他の状態をセットアップできます。

Julia 1.12

この型を使用するには、Julia 1.12以降が必要です。

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())
true
source
Base.OncePerTask — Type
OncePerTask{T}(init::Function)() -> T

OncePerTask オブジェクトを呼び出すと、Task ごとに関数 initializer がちょうど 1 回実行され、その戻り値として型 T の値が返されます。同じ Task 内で以降に呼び出した場合は、常にまったく同じ値が返されます。

関連項目: task_local_storage。

Julia 1.12

この型を使用するには、Julia 1.12 以降が必要です。

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.
false
source
Base.OncePerThread — Type
OncePerThread{T}(init::Function)() -> T

OncePerThread オブジェクトを呼び出すと、スレッドごとに関数 initializer がちょうど1回実行され、T 型の値が返されます。同じスレッドでの以降の呼び出しや、同じスレッド ID を指定した並行または将来の呼び出しでは、常にまったく同じ値が返されます。また、既存の任意のスレッドの threadid でこのオブジェクトをインデックスすると、そのスレッドに保存された値を取得できます(または、このスレッド上で初期化できます)。誤った使い方はデータ競合やメモリ破損につながる可能性があるため、ライブラリのスレッド安全性の設計上、その動作が適切な場合にのみ使用してください。

Warning

Task が必ず1つのスレッドだけで実行されるとは限りません。そのため、ここで返される値は他の値とエイリアスする場合や、プログラムの実行中に変化する場合があります。この関数は将来非推奨になる可能性があります。initializer が yield すると、この呼び出しの後に現在のタスクを実行するスレッドは、呼び出し開始時のスレッドと異なる場合があります。

関連項目: OncePerTask。

Julia 1.12

この型を使用するには Julia 1.12 以降が必要です。

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()]
true
source
Base.which — Method
which(f, types)

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

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

関連項目:parentmodule、@which、@edit。

source
Base.methods — Function
methods(f, [types], [module])

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

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

Julia 1.4

モジュールを指定するには、Julia 1.4以降が必要です。

関連項目: which、@which、methodswith。

source
Base.@show — Macro
@show exs...

1つ以上の式とその結果をstdoutに出力し、最後の結果を返します。

関連項目: show、@info、println。

Examples

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

julia> @show x^2 x/2;
x ^ 2 = 9
x / 2 = 1.5
source
Base.MainInclude.ans — Constant
ans

対話プロンプトに自動的にインポートされる、最後に計算された値を参照する変数。

source
Base.MainInclude.err — Constant
err

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

source
Base.set_active_project — Function
set_active_project(projfile::Union{AbstractString,Nothing})

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

Julia 1.8

この関数を使用するには、Julia 1.8以降が必要です。

source
Base.active_manifest — Function
active_manifest()
active_manifest(project_file::AbstractString)

アクティブなマニフェストファイル、または指定した project_file に対して使用されるマニフェストファイルのパスを返します。

複数の環境がロードパス上に存在するスタック環境では、スタック内の他の環境のマニフェストではなく、プライマリ(アクティブ)環境のマニフェストファイルのみを返します。スタック環境の詳細については、マニュアルの Environment stacks の節を参照してください。

プロジェクトとマニフェストの違いや、パッケージのロード時に使われる名前の選択肢とその優先順位については、Project environments を参照してください。

Base.active_project、Base.set_active_project も参照してください。

Julia 1.13

この関数を使用するには、Julia 1.13 以降が必要です。

source

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
module

module は 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)")
end
source
export — Keyword
export

exportは、モジュール内で、どの名前をユーザーが利用できるようにするかをJuliaに伝えるために使われます。たとえば、export fooを使うと、モジュールをusingしたときに、名前fooが利用可能になります。詳しくはmanual section about modulesを参照してください。

source
public — Keyword
public

publicは、モジュール内で、どの名前がそのモジュールの公開APIに含まれるかをJuliaに伝えるために使います。たとえば、public fooは、fooという名前が公開されていることを示しますが、usingそのモジュールから利用可能になるわけではありません。

exportはすでに名前が公開されていることを示すため、同じ名前をpublicとexportedの両方で宣言する必要はなく、宣言するとエラーになります。詳しくはmanual section about modulesを参照してください。

Julia 1.11

publicキーワードはJulia 1.11で追加されました。それ以前は、公開性の概念はより明示的ではありませんでした。

source
import — Keyword
import

import Fooを実行すると、モジュールまたはパッケージFooが読み込まれます。インポートしたモジュールFooの名前には、ドット構文でアクセスできます(例:Foo.fooを使って名前fooにアクセスします)。詳しくはmanual section about modulesを参照してください。

source
using — Keyword
using

using Fooを実行すると、モジュールまたはパッケージFooが読み込まれ、exportされた名前を直接使えるようになります。名前は、exportされているかどうかにかかわらず、ドット構文(例:名前fooにアクセスするFoo.foo)でも使えます。詳しくはmanual section about modulesを参照してください。

Note

2つ以上のパッケージ/モジュールが同じ名前をエクスポートしていて、その名前が各パッケージで同じものを指していない場合、名前のリストを明示せずにusingでパッケージを読み込むと、その名前を修飾なしで参照することはエラーになります。そのため、依存パッケージやJuliaの将来のバージョンとの互換性を保つ必要があるコード(リリース済みパッケージのコードなど)では、読み込んだ各パッケージから使用する名前を列挙することを推奨します。たとえば、using Fooではなくusing Foo: Foo, fを使います。

source
as — Keyword
as

asは、importまたはusingによってスコープに取り込まれた識別子の名前を変更するキーワードです。名前の衝突を回避したり、名前を短くしたりする目的で使用します。(import文またはusing文の外では、asはキーワードではなく、通常の識別子として使用できます。)

import LinearAlgebra as LAを使うと、インポートされた標準ライブラリLinearAlgebraがLAとしてスコープに取り込まれます。

import LinearAlgebra: eigen as eig, cholesky as cholを使うと、LinearAlgebraのメソッドeigenとcholeskyが、それぞれeigとcholとしてスコープに取り込まれます。

asは、個々の識別子をスコープに取り込む場合にのみ、usingと併用できます。たとえば、using LinearAlgebra: eigen as eigやusing LinearAlgebra: eigen as eig, cholesky as cholは有効ですが、using LinearAlgebra as LAは構文として無効です。LinearAlgebraからエクスポートされた名前をすべてLAに変更するのは意味をなさないためです。

source
baremodule — Keyword
baremodule

baremodule は、using Base を含まず、eval と include のローカル定義も持たないモジュールを宣言します。ただし、Core はインポートします。つまり、

module Mod

...

end

と同等です。

baremodule Mod

using Base

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

...

end
source
function — Keyword
function

関数は、function キーワードを使って定義します。

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

または、短縮形の記法を使います。

add(a, b) = a + b

return キーワードの使い方は他の言語とまったく同じですが、省略できる場合がよくあります。明示的な return 文がない関数は、関数本体の最後の式を返します。

source
macro — Keyword
macro

macroは、プログラムに生成コードを挿入するためのメソッドを定義します。マクロは引数式の列を受け取り、返された式を、マクロが呼び出された位置にプログラムへ直接置き換えます。生成コードは周囲のプログラムの一部となるため、マクロを使えば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 friend
source
return — Keyword
return

return x は、指定された値 x を呼び出し元に返し、現在の関数を早期に終了します。値を指定せずに return だけを使うと、return nothing と同じ意味になります(nothing を参照)。

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

一般に、関数本体のどこにでも return 文を置けます。深くネストしたループや条件分岐の中でも使えますが、do ブロックでは注意が必要です。たとえば、次のようになります。

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

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

最初の例では、偶数に達すると return によって test1 から抜けるため、test1([5,6,7]) は 12 を返します。

2つ目の例も同じように動作すると思うかもしれませんが、実際には、そこでの return は(do ブロック内の)内側の関数だけを終了し、値を map に返します。その後、test2([5,6,7]) は [5,12,7] を返します。

トップレベルの式(つまり、関数の外側)で使うと、return は現在のトップレベル式全体を早期に終了します。

source
do — Keyword
do

無名関数を作成し、関数呼び出しの第1引数として渡します。たとえば、次のようにします。

map(1:10) do x
    2x
end

これは map(x->2x, 1:10) と同等です。

複数の引数を使う場合は、次のようにします。

map(1:10, 11:20) do x, y
    x + y
end
source
begin — Keyword
begin

begin...end はコードブロックを表します。

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

通常、begin は必要ありません。function や let などのキーワードは、暗黙的にコードブロックを開始するためです。; も参照してください。

インデックス指定では、コレクションの最初のインデックスや配列の次元の最初のインデックスを表すために、begin を使うこともできます。たとえば、a[begin] は配列 a の最初の要素です。

Julia 1.4

インデックスとして begin を使うには、Julia 1.4 以降が必要です。

Examples

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

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

endは、式のブロックの終わりを示します。たとえば、module、struct、mutable struct、begin、let、forなどです。

endは、コレクションの最後のインデックスや、配列の次元の最後のインデックスを表すために、インデックス指定で使われることもあります。

Examples

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

julia> A[end, :]
2-element Vector{Int64}:
 3
 4
source
let — Keyword
let

let ブロックは新しいハードスコープを作り、必要に応じて新しいローカル束縛を導入します。

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
 3
source
if — Keyword
if/elseif/else

if/elseif/elseは条件評価を行います。これにより、ブール式の値に応じてコードの一部を評価するかどうかを決められます。if/elseif/else条件構文の構成は次のとおりです。

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

条件式x < yがtrueの場合、対応するブロックが評価されます。そうでない場合は、条件式x > yが評価され、trueであれば対応するブロックが評価されます。どちらの式もtrueでない場合は、elseブロックが評価されます。elseifブロックとelseブロックは省略可能で、elseifブロックは必要な数だけ使用できます。

一部の他の言語とは異なり、条件の型はBoolでなければなりません。条件がBoolに変換可能であるだけでは不十分です。

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

for ループは、値の列を反復処理しながら、文のブロックを繰り返し評価します。

反復変数は常に新しい変数です。外側のスコープに同じ名前の変数があっても、その変数は使われません。反復に既存のローカル変数を再利用するには、outer を使います。

Examples

julia> for i in [1, 4, 0]
           println(i)
       end
1
4
0
source
while — Keyword
while

while ループでは条件式を繰り返し評価し、条件式が真である限り、while ループの本体を実行し続けます。while ループに初めて到達した時点で条件式が偽の場合、本体は一度も実行されません。

Examples

julia> i = 1
1

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

ループを直ちに抜けます。

Examples

julia> i = 0
0

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

現在のループ反復の残りをスキップします。

Examples

julia> for i = 1:6
           iseven(i) && continue
           println(i)
       end
1
3
5
source
try — Keyword
try/catch

try/catch文は、throwがスローするエラー(例外)を捕捉し、プログラムの実行を続行できるようにします。たとえば、次のコードはファイルへの書き込みを試みますが、書き込めない場合は実行を終了せず、ユーザーに警告して処理を続けます。

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

ファイルを変数に読み込めない場合は、次のようになります。

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

構文catch e(eは任意の変数)は、スローされた例外オブジェクトを、指定した変数にcatchブロック内で代入します。

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

try/catch構文の利点は、深くネストされた計算から、呼び出し関数のスタック上のはるかに高いレベルへ直ちに巻き戻せることです。

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

try
    a_dangerous_operation()
catch
    @warn "The operation failed."
else
    @info "The operation succeeded."
end

tryブロックまたはtry/catchブロックには、例外が発生したかどうかにかかわらず最後に実行されるfinally節を付けることもできます。たとえば、開いたファイルが必ず閉じられるようにするために使えます。

f = open("file")
try
    operate_on_file(f)
catch
    @warn "An error occurred!"
finally
    close(f)
end

(finallyは、catchブロックなしでも使用できます。)

Julia 1.8

else節を使用するには、Julia 1.8以降が必要です。

source
finally — Keyword
finally

指定したtryコードブロックがどのように終了しても、その終了時にコードを実行できます。たとえば、開いたファイルが必ず閉じられるようにするには、次のようにします。

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

tryブロックから制御が抜けると(たとえば、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
2
source
quote — Keyword
quote

quoteは、明示的なExprコンストラクターを使わずに、ブロック内に複数の式オブジェクトを作成します。たとえば、次のようになります。

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

もう一方のクォート方法である:( ... )とは異なり、この形式では式ツリーにQuoteNode要素が追加されるため、ツリーを直接操作する際にはその点を考慮する必要があります。それ以外の用途では、:( ... )ブロックとquote .. endブロックは同じように扱われます。

source
local — Keyword
local

local は新しいローカル変数を導入します。詳しくは 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)
0
source
global — Keyword
global

global 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
6
source
outer — Keyword
for outer

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

詳しくはmanual section on variable scopingをご覧ください。

こちらもご覧ください:for。

Examples

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

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

julia> f()
3
julia> i = 0 # global variable
       for outer i = 1:3
       end
ERROR: syntax: no outer local variable declaration exists for "for outer"
[...]
source
const — Keyword
const

constは、値が変わらないグローバル変数を宣言するために使います。ほとんどのコード、特に性能が重要なコードでは、グローバル変数をこの方法で定数として宣言する必要があります。

const x = 5

1つのconst内で、複数の変数を宣言できます。

const y, z = 7, 11

constは1つの=演算にのみ適用されるため、const x = y = 1ではxは定数として宣言されますが、yは定数として宣言されません。一方、const x = const y = 1では、xとyの両方が定数として宣言されます。

「定数であること」は、変更可能なコンテナの中身には及びません。定数なのは、変数とその値との結び付きだけです。たとえば、xが配列や辞書であれば、要素の変更、追加、削除は引き続き可能です。

場合によっては、const変数の値を変更してもエラーではなく警告が表示されます。しかし、予測できない動作やプログラムの状態の破損につながる可能性があるため、変更は避けてください。この機能は、対話的な使用時の利便性のみを目的としています。

source
struct — Keyword
struct

Juliaで最もよく使われる型は、名前とフィールドの集合で定義する構造体です。

struct Point
    x
    y
end

フィールドには型制約を指定できます。また、型パラメーターを使うこともできます。

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

構造体では、<:構文を使って抽象スーパータイプを宣言することもできます。

struct Point <: AbstractPoint
    x
    y
end

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

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

source
mutable struct — Keyword
mutable struct

mutable structはstructに似ていますが、構築後に型のフィールドを設定できる点が異なります。

可変構造体の個々のフィールドにはconstを指定して、不変にできます。

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

可変構造体のフィールドにconstキーワードを使用するには、Julia 1.8以降が必要です。

詳しくは、Composite Typesに関するマニュアルの節を参照してください。

source
Base.@kwdef — Macro
@kwdef typedef

これは、式 typedef で宣言された型に対して、キーワード引数を使うコンストラクターを自動的に定義するヘルパーマクロです。この式は struct または mutable struct でなければなりません。デフォルト引数は、フィールドを field::T = default または field = default の形式で宣言することで指定します。デフォルト値を指定しない場合、生成される型コンストラクターでは、そのキーワード引数が必須になります。

内部コンストラクターも定義できますが、キーワード外部コンストラクターが正しく機能するには、少なくとも1つはデフォルトの内部コンストラクターと同じ形式(つまり、フィールドごとに1つの位置引数を取る形式)で引数を受け取る必要があります。

Julia 1.1

パラメトリック構造体およびスーパータイプを持つ構造体に対する Base.@kwdef には、Julia 1.1 以降が必要です。

Julia 1.9

このマクロは Julia 1.9 以降でエクスポートされています。

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:
[...]
source
abstract type — Keyword
abstract type

abstract typeはインスタンス化できない型を宣言します。型グラフのノードとしてのみ機能し、関連する具象型の集合、すなわちその子孫にあたる具象型を表します。抽象型は概念上の階層を形成し、Juliaの型システムを単なるオブジェクト実装の集合以上のものにしています。たとえば、次のようになります。

abstract type Number end
abstract type Real <: Number end

Numberにはスーパータイプがありません。一方、RealはNumberの抽象サブタイプです。

source
primitive type — Keyword
primitive type

primitive typeは、データがビット列のみで構成される具象型を宣言します。プリミティブ型の代表例として、整数や浮動小数点数があります。組み込みプリミティブ型の宣言例をいくつか示します。

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

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

source
where — Keyword
where

whereキーワードは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, ...}構文を使って型をパラメーター値に「適用」するときに、変数が置き換えられる順序と一致します。

source
... — Keyword
...

「スプラット」演算子 ... は、引数の列を表します。関数定義で ... を使うと、その関数が任意の数の引数を受け取ることを示せます。また、引数の列に関数を適用する際にも ... を使えます。

Examples

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

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

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

julia> add(7, 1:100..., 1000:1100...)
111107
source
; — Keyword
;

セミコロンは文の区切りとして使われるほか、関数の宣言や呼び出しでキーワード引数の開始を示します。

source
= — 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
source
?: — 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"
source
.= — 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
source
. — Keyword
.

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

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

Examples

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

julia> Iterators.product
product (generic function with 1 method)
source
-> — 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 のマニュアルの節を参照してください。

source
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}
source
:: — 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
source

Standard Modules

Main — Module
Main

Mainは最上位モジュールであり、JuliaはMainを現在のモジュールとして起動します。プロンプトで定義した変数はMainに格納され、varinfoはMain内の変数を一覧表示します。

julia> @__MODULE__
Main
source
Core — Module
Core

Coreは、言語に「組み込み」と見なされるすべての識別子、つまりライブラリではなく言語の中核を成す識別子を含むモジュールです。これらの定義がなければ何もできないため、すべてのモジュールでusing Coreが暗黙的に指定されます。

source
Base — Module
Base

Julia の基本ライブラリ。Base は、基本的な機能(base/ の内容)を含むモジュールです。ほとんどの場合に必要となるため、すべてのモジュールには暗黙的に using Base が含まれています。

source

Base Submodules

Base.Broadcast — Module
Base.Broadcast

ブロードキャストの実装を含むモジュール。

source
Base.Docs — Module
Docs

Docs モジュールは、Julia オブジェクトのドキュメントメタデータを設定および取得するための @doc マクロを提供します。

詳しくは、documentation のマニュアルをご覧ください。

source
Base.Libc — Module

libc(C標準ライブラリ)へのインターフェース。

source
Base.Meta — Module

メタプログラミング用の便利な関数。

source
Base.StackTraces — Module

スタックトレースの収集・操作に使うツール。主にエラーの構築に使用します。

source
Base.Sys — Module

ハードウェアおよびオペレーティングシステムに関する情報を取得するメソッドを提供します。

source
Base.GC — Module
Base.GC

ガベージコレクション用ユーティリティを含むモジュール。

source

All Objects

Core.:(===) — Function
===(x,y)::Bool
≡(x,y)::Bool

xとyが、どのプログラムからも区別できないという意味で同一かどうかを判定します。まず、xとyの型を比較します。型が同一であれば、可変オブジェクトはメモリ上のアドレスで比較し、不変オブジェクト(数値など)はビット単位の内容で比較します。この関数は「egal」と呼ばれることもあります。常にBool値を返します。

Examples

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

julia> a == b
true

julia> a === b
false

julia> a === a
true
source
Core.isa — Function
isa(x, type)::Bool

xが、指定されたtypeであるかどうかを判定します。中置演算子としても使用できます。例:x isa type。

Examples

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true
source
Base.isequal — Function
isequal(x)

引数を isequal を使って x と比較する関数を作成します。つまり、y -> isequal(y, x) と同等の関数です。

返される関数の型は Base.Fix2{typeof(isequal)} で、これを使って特化したメソッドを実装できます。

source
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)
true
source
Base.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")
false
source
Base.ispositive — Function
ispositive(x)

x > 0かどうかをテストします。isnegativeも参照してください。

Julia 1.13

この関数を使用するには、Julia 1.13以降が必要です。

Examples

julia> ispositive(-4.0)
false

julia> ispositive(99)
true

julia> ispositive(0.0)
false
source
Base.isnegative — Function
isnegative(x)

x < 0かどうかをテストします。ispositiveも参照してください。

Julia 1.13

この関数を使用するには、Julia 1.13 以降が必要です。

Examples

julia> isnegative(-4.0)
true

julia> isnegative(99)
false

julia> isnegative(-0.0)
false
source
Base.isunordered — Function
isunordered(x)

xが<に従って順序付けできない値(NaNやmissingなど)の場合、trueを返します。

この述語でtrueと評価される値でも、islessなど、別の順序関係では順序付けできる場合があります。

Julia 1.7

この関数を使用するには、Julia 1.7以降が必要です。

source
Base.ifelse — Function
ifelse(condition::Bool, x, y)

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

Examples

julia> ifelse(1 > 2, 1, 2)
2
source
Core.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:
[...]
source
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})
source
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, π)
source
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)
source
ntuple(f, n::Integer)

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

Examples

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)
source
Base.objectid — Function
objectid(x)::UInt

オブジェクトの同一性に基づいて、xのハッシュ値を取得します。この値は一意ではなく、Juliaのプロセスやバージョンが異なると安定しません。

x === yの場合はobjectid(x) == objectid(y)となり、通常はx !== yの場合はobjectid(x) != objectid(y)となります。

hash、IdDictも参照してください。

source
Base.hash — Function
hash(x[, h::UInt])::UInt

isequal(x,y)がisequal(hash(x), hash(y))を意味するような整数ハッシュコードを計算します。省略可能な第2引数hは、結果と混合する別のハッシュコードです。

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

ハッシュ値は、新しいJuliaプロセスを開始すると変わることがあります。

Warning

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

関連項目: objectid、Dict、Set。

source
Base.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
end
source
Base.finalize — Function
finalize(x)

オブジェクト x に登録されているファイナライザーを直ちに実行します。

source
Base.copy — Function
copy(x)

xの浅いコピーを作成します。外側の構造はコピーされますが、内部の値がすべてコピーされるわけではありません。たとえば、配列をコピーすると、元の配列と同一の要素を持つ新しい配列が作成されます。

copy!、copyto!、deepcopyも参照してください。

source
Base.deepcopy — Function
deepcopy(x)

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

通常は必要ありませんが、ユーザー定義型では、関数deepcopy_internal(x::T, dict::IdDict)の特殊化版(通常は使用すべきではありません)を定義することで、デフォルトのdeepcopyの動作をオーバーライドできます。ここで、Tは特殊化の対象となる型で、dictは再帰処理中にコピー済みのオブジェクトを記録します。定義内では、deepcopyの代わりにdeepcopy_internalを使用し、戻り値を返す前にdict変数を適切に更新してください。

Warning

この関数は避け、カスタムのcopyメソッドや、用途に応じたコピー関数を使うことをお勧めします。deepcopyは低速で、抽象化の境界を尊重しないため、必要以上に多くのオブジェクトをコピーしたり、不変条件に違反するオブジェクトを生成したりするおそれがあります。

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

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

getfield、propertynames、setproperty! も参照してください。

source
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) を呼び出します。

Julia 1.8

モジュールに対する setproperty! の使用には、Julia 1.8 以降が必要です。

setfield!、propertynames、getproperty も参照してください。

source
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 という構文も使用できます。

関連項目: replacefield! setproperty!、setpropertyonce!。

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

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

source
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を使用できます。

関連項目:setfieldonce!、setproperty!、replaceproperty!。

Julia 1.11

この関数を使用するには、Julia 1.11以降が必要です。

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

source
Base.hasproperty — Function
hasproperty(x, s::Symbol)

オブジェクト x が、s を自身のプロパティとして持つかどうかを示すブール値を返します。

Julia 1.2

この関数を使用するには、Julia 1.2 以降が必要です。

関連項目: propertynames、hasfield。

source
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)
1
source
Core.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 changed
source
Core.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

ハードウェアが対応している場合(アトミックなインクリメントなど)は、適切なハードウェア命令に最適化されることがあります。対応していない場合は、ループを使用します。

Julia 1.7

この関数を使用するには、Julia 1.7 以降が必要です。

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

ハードウェアが対応している場合は、適切なハードウェア命令に最適化されます。対応していない場合は、ループを使用します。

Julia 1.7

この関数を使用するには、Julia 1.7 以降が必要です。

source
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 y
Julia 1.7

この関数を使用するには、Julia 1.7 以降が必要です。

source
Core.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 ok
Julia 1.11

この関数を使用するには、Julia 1.11 以降が必要です。

source
Core.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)
false
source
Core.isdefinedglobal — Function
isdefinedglobal(m::Module, s::Symbol, [allow_import::Bool=true, [order::Symbol=:unordered]])

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

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

Julia 1.12

この関数を使用するには、Julia 1.12 以降が必要です。

関連項目: @isdefined。

Examples

julia> isdefinedglobal(Base, :sum)
true

julia> isdefinedglobal(Base, :NonExistentMethod)
false

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

julia> isdefinedglobal(Main, :sum, false)
false
source
Base.@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
true
source
Base.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.333333333333333314829616256247390992939472198486328125

Tがコレクション型で、xもコレクションの場合、convert(T, x)の結果は、xの全体または一部とメモリを共有することがあります。

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

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

julia> y === x
true

関連項目: round、trunc、oftype、reinterpret。

source
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)
Any
source
Base.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.0
source
Base.widen — Function
widen(x)

x が型の場合、算術演算 + および - でオーバーフローや精度の損失が発生しないことが、x 型で表現可能な値のあらゆる組み合わせについて保証される「より大きな」型を返します。

128 ビット未満の固定サイズ整数型の場合、widen はビット数が 2 倍の型を返します。

x が値の場合は、widen(typeof(x)) に変換されます。

Examples

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5
source
Base.identity — Function
identity(x)

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

関連項目: one、oneunit、および LinearAlgebra の I。

Examples

julia> identity("Well, what did you expect?")
"Well, what did you expect?"
source
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)
source

Properties of Types

Type relations

Base.supertype — Function
supertype(T::Union{DataType, UnionAll})

型 T の直接のスーパータイプを返します。T は、DataType 型または UnionAll 型を指定できます。Union 型には対応していません。Types も参照してください。

Examples

julia> supertype(Int32)
Signed

julia> supertype(Vector)
DenseVector (alias for DenseArray{T, 1} where T)
source
Core.Type — Type
Core.Type{T}

Core.Typeは、すべての型オブジェクトをインスタンスとして持つ抽象型です。シングルトン型Core.Type{T}のインスタンスは、オブジェクトTだけです。

Examples

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

julia> isa(Float64, Type)
true

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

julia> isa(Real, Type{Real})
true
source
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)
DataType
source
Core.:<: — Function
<:(T1, T2)::Bool

2つの型の間に定義される部分型関係。Juliaでは、型 S が型 T の 部分型 であるとは、S <: T が成り立つことをいいます。

任意の型 L と任意の型 R について、L <: R ならば、型 L の任意の値 v は、型 R でもあります。つまり、(L <: R) && (v isa L) ならば、v isa R です。

部分型関係は 半順序 です。つまり、<: は次の性質を持ちます。

  • 反射的: 任意の型 T について、T <: T が成り立つ
  • 反対称的: 任意の型 A と任意の型 B について、(A <: B) && (B <: A) ならば A == B が成り立つ
  • 推移的: 任意の型 A、任意の型 B、任意の型 C について、(A <: B) && (B <: C) ならば A <: C が成り立つ

Types、Union{}、Any、isa も参照してください。

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 を参照。
source
Core.:>: — Function
>:(T1, T2)

上位型演算子。T2 <: T1と同等です。

source
Base.typejoin — Function
typejoin(T, S, ...)

T と S の最も近い共通祖先、つまり両方が継承する型のうち最も限定的なものを返します。追加の可変長引数がある場合は、再帰的に処理します。

Examples

julia> typejoin(Int, Float64)
Real

julia> typejoin(Int, Float64, ComplexF32)
Number
source
Base.typeintersect — Function
typeintersect(T::Type, S::Type)

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

次の場合は、特別に正確な動作が保証されます。T <: S、typeintersect(S, T) == T == typeintersect(T, S)。

source
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 を直接オーバーロードすると、曖昧性エラーが発生することがあります。

source
Base.promote_rule — Function
promote_rule(type1, type2)

promote に型 type1 および type2 の値が渡されたときに、どの型を使用するかを指定します。この関数を直接呼び出すべきではありません。新しい型を追加する際は、必要に応じてこの関数に定義を追加してください。

source
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)
Float64
source
Base.isdispatchtuple — Function
isdispatchtuple(T)

型 T が、ディスパッチで型シグネチャとして使われる可能性のある Tuple かどうかを判定します。これに該当するには、タプル型の各要素が次のいずれかでなければなりません。

Note

ディスパッチタプルには要素を持つ部分型がないため、メソッドディスパッチにおいて重要です。

たとえば、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})
false
source

Declared structure

Base.ismutable — Function
ismutable(v)::Bool

値 v が可変である場合に限り、true を返します。不変性については Mutable Composite Types を参照してください。この関数は値を対象とするため、DataType を渡すと、その型の値は可変であると判定されます。

Note

技術的な理由により、ismutable は、String や Symbol など、一部の特殊な型の値について、許容される方法では変更できないにもかかわらず、true を返します。

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

Examples

julia> ismutable(1)
false

julia> ismutable([1,2])
true
Julia 1.5

この関数を使用するには、Julia 1.5 以降が必要です。

source
Base.isimmutable — Function
isimmutable(v) -> Bool
Warning

isimmutable(v) は将来のリリースで !ismutable(v) に置き換えられるため、代わりに !ismutable(v) を使用することを検討してください。(Julia 1.5 以降)

値 v が不変の場合に限り、true を返します。不変性については Mutable Composite Types を参照してください。この関数は値を対象とするため、型を渡すと、DataType の値は可変であると判定されます。

Examples

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false
source
Base.ismutabletype — Function
ismutabletype(T)::Bool

T 型が可変型として宣言されているか(つまり、mutable struct キーワードを使って宣言されているか)を判定します。T が型でない場合は、false を返します。

Julia 1.7

この関数を使用するには、Julia 1.7 以降が必要です。

source
Base.isabstracttype — Function
isabstracttype(T)

型 T が抽象型として宣言されているか(つまり、abstract type 構文を使用しているか)を判定します。T が型でない場合は、false を返します。

Note

抽象型は concrete ではなく、その逆も同様ですが、具体型でも抽象型でもない型もあります(たとえば、Vector(UnionAll))。

関連項目: isconcretetype。

Examples

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false
source
Base.isprimitivetype — Function
isprimitivetype(T)::Bool

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

source
Base.issingletontype — Function
Base.issingletontype(T)

型 T が、唯一のインスタンスだけを持つかどうかを判定します。たとえば、他のシングルトン値だけをフィールドに持つ構造体型が該当します。T が具象型でない場合は、false を返します。

source
Base.isstructtype — Function
isstructtype(T)::Bool

型 T が構造体型(つまり、struct または mutable struct キーワードを使って宣言された型)かどうかを判定します。T が型でない場合は、false を返します。

source
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)
:S
source
Base.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)
source
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)
2
source
Base.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)
0
Julia 1.13

この関数は Julia 1.13 以降でエクスポートされています。

source
Core.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)
String
source
Base.fieldtypes — Function
fieldtypes(T::Type)

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

Julia 1.1

この関数を使用するには、Julia 1.1 以降が必要です。

Examples

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

julia> fieldtypes(Foo)
(Int64, String)
source
Base.fieldcount — Function
fieldcount(t::Type)

指定された型のインスタンスが持つフィールド数を取得します。型が抽象的すぎてフィールド数を特定できない場合は、エラーがスローされます。

source
Base.hasfield — Function
hasfield(T::Type, name::Symbol)

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

関連項目: fieldnames、fieldcount、hasproperty。

Julia 1.2

この関数を使用するには、Julia 1.2 以降が必要です。

Examples

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false
source
Core.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 です。

source
Base.isconst — Function
isconst(t::DataType, s::Union{Int,Symbol})::Bool

指定された型 t において、フィールド s が const かどうかを判定します。ここでいう const とは、等しいオブジェクト間でそのフィールドを読み取った結果が一致することを意味します。特に、範囲外のフィールドもこの定義では const とみなされる点に注意してください(常に例外をスローするためです)。

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

指定されたモジュール m において、グローバル変数が const かどうかを判定します。定数として宣言されている場合と、定数束縛からインポートされている場合のどちらも該当します。定数であるかどうかは特定のワールドエイジに依存するため、ワールドエイジが更新された後もこの関数の結果が有効だとは限りません。

source
Base.isfieldatomic — Function
isfieldatomic(t::DataType, s::Union{Int,Symbol})::Bool

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

source

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
9

DataType T のサイズが定まっていない場合は、エラーがスローされます。

julia> sizeof(AbstractArray)
ERROR: Abstract type AbstractArray does not have a definite size.
Stacktrace:
[...]
source
Base.isconcretetype — Function
isconcretetype(T)

型 T が具象型かどうか、つまり直接インスタンス(x を満たす値 typeof(x) === T)を持ち得るかどうかを判定します。これは isabstracttype(T) の否定ではないことに注意してください。T が型でない場合は、false を返します。

Note

具象型は abstract ではなく、その逆も成り立ちますが、具象型でも抽象型でもない型もあります(たとえば、Vector(UnionAll))。

Note

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)
false
source
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)
false
source
Base.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)
Julia 1.13

インデックスではなく名前でフィールドを指定するには、Julia 1.13 以降が必要です。

source
Base.datatype_alignment — Function
Base.datatype_alignment(dt::DataType)::Int

この型のインスタンスに必要なメモリ割り当ての最小アラインメント。任意のisconcretetypeに対して呼び出せますが、Memoryの場合はオブジェクト全体ではなく、要素のアラインメントが返されます。

source
Base.datatype_haspadding — Function
Base.datatype_haspadding(dt::DataType)::Bool

この型のインスタンスのフィールドが、メモリ上で隙間なく配置されているかどうかを返します。ここでいう隙間とは、インスタンス自体の意味上の値に影響しないビットを指します。任意のisconcretetypeに対して呼び出せます。

source
Base.datatype_pointerfree — Function
Base.datatype_pointerfree(dt::DataType)::Bool

この型のインスタンスが、GC 管理メモリへの参照を含む可能性があるかどうかを返します。任意の isconcretetype に対して呼び出せます。

source

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
true
source
Base.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.4028235f38
source
Base.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-308
source
Base.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)
Inf
source
Base.maxintfloat — Function
maxintfloat(T, S)

指定された浮動小数点型 T で表現でき、かつ整数型 S で表現可能な最大の整数を超えない、連続する整数のうち最大のもの。言い換えると、maxintfloat(T) と typemax(S) の最小値です。

source
maxintfloat(T=Float64)

指定された浮動小数点型 T(デフォルトは Float64)で正確に表現できる、連続する整数値の浮動小数点数のうち最大のもの。

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

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

関連項目: typemax、floatmax。

source
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)$ となります。

source
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.7976931348623157e308
source
Base.instances — Function
instances(T::Type)

該当する場合は、指定された型のすべてのインスタンスを返します。主に列挙型で使用されます(@enumを参照)。

Examples

julia> @enum Color red blue green

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

Special Types

Core.Any — Type
Any::DataType

Anyは、すべての型の和集合です。任意のxに対して、isa(x, Any) == trueという性質を持ちます。したがって、Anyは、取り得る値の全体を表します。たとえば、IntegerはAnyの部分集合であり、Int、Int8などの整数型を含みます。

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

Extended Help

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

空のUnion型であるUnion{}は、Juliaのボトム型です。

source
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)
false
source
Core.TypeofBottom — Type
Core.TypeofBottom

値 Union{} のみを含むシングルトン型(これは空型を表します)。

source
Core.UnionAll — Type
UnionAll

型パラメーターが取り得るすべての値に対する型の和集合。UnionAllは、一部のパラメーターの値が不明なパラメトリック型を表すために使われます。UnionAll Typesのマニュアルの節を参照してください。

Examples

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType
source
Core.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も参照してください。

source
Core.NTuple — Type
NTuple{N, T}

すべての要素がT型である、長さNのタプルの型を簡潔に表す方法です。

Examples

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

ntupleも参照してください。

source
Core.NamedTuple — Type
NamedTuple

NamedTupleは、その名のとおり、名前付きのTupleです。つまり、各要素に一意の名前が付いた、タプルに似た値のコレクションであり、名前はSymbolで表されます。Tupleと同様に、NamedTupleは不変です。構築後に名前や値をその場で変更することはできません。

名前付きタプルは、キーを指定したタプルリテラル(例:(a=1, b=2))、開き括弧の後にセミコロンを置いたタプルリテラル(例:(; a=1, b=2)。この形式では、後述のようにプログラムで生成した名前も使用できます)、またはNamedTuple型をコンストラクターとして使う方法(例:NamedTuple{(:a, :b)}((1,2)))で作成できます。

名前付きタプルの名前に対応する値には、フィールドアクセス構文(例:x.a)またはgetindexを使ってアクセスできます(例:x[:a]、x[(:a, :b)])。名前のタプルはkeysで、値のタプルはvaluesで取得できます。

Note

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,)
Julia 1.5

識別子やドット式から名前を暗黙的に取得できるようになったのは、Julia 1.5以降です。

Julia 1.7

複数のSymbolを指定したgetindexメソッドが使えるのは、Julia 1.7以降です。

source
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}
Julia 1.5

このマクロは Julia 1.5 以降で利用できます。

source
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]:1
Julia 1.10

このマクロはJulia 1.10以降で利用できます。

source
Base.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"
source
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)
false
source
Base.notnothing — Function
notnothing(x)

x === nothing の場合はエラーをスローし、そうでなければ x を返します。

source
Base.Some — Type
Some{T}

Union{Some{T}, Nothing}で、値が存在しない状態(nothing)と、nothingの値が存在する状態(つまりSome(nothing))を区別するために使われるラッパー型です。

Someオブジェクトにラップされた値にアクセスするには、somethingを使います。

source
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 present
source
Base.@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
true
Julia 1.7

このマクロはJulia 1.7以降で利用できます。

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

BaseType は、デフォルトでは Int32 となり、Integer のプリミティブサブタイプでなければなりません。メンバー値は、列挙型と BaseType の間で相互に変換できます。read と write は、これらの変換を自動的に行います。列挙型をデフォルト以外の BaseType で作成した場合、Integer(value1) は、型が BaseType の整数 value1 を返します。

列挙型のすべてのインスタンスを列挙するには、instances を使用します。たとえば、

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

列挙型のインスタンスからシンボルを構築することもできます。

julia> Symbol(apple)
:apple
source
Core.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 c
source
Core.Symbol — Type
Symbol

パースされた Julia コード(AST)で識別子を表すために使われるオブジェクトの型です。また、エンティティを識別する名前やラベル(たとえば辞書のキー)として使われることもよくあります。Symbol は、: クォート演算子を使って入力できます。

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

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

Symbol は不変であり、同じ名前を持つすべての Symbol に対して、実装では同じオブジェクトが再利用されます。

文字列とは異なり、Symbol は「アトミック」または「スカラー」なエンティティであり、文字単位の反復処理には対応していません。

source
Core.Symbol — Method
Symbol(x...)::Symbol

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

Examples

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

julia> Symbol("day", 4)
:day4
source
Core.Module — Type
Module

Moduleは、独立したグローバル変数のワークスペースです。詳しくは、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もインポートせず、自身への参照も含みません。

source

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
true
source
Base.hasmethod — Function
hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=get_world_counter())::Bool

指定された引数型のTupleに一致するメソッドが、world ageの上限をworldとして、指定された汎用関数に存在するかどうかを判定します。

キーワード引数名のタプルkwnamesが指定されている場合、tに一致するfのメソッドが、指定されたキーワード引数名を受け付けるかどうかも確認します。一致するメソッドが、たとえばkwargs...のように可変個数のキーワード引数を受け付ける場合、kwnamesで指定された名前はすべて有効とみなされます。それ以外の場合、指定する名前はメソッドのキーワード引数の部分集合でなければなりません。

関連項目: applicable。

Julia 1.2

キーワード引数名を指定するには、Julia 1.2以降が必要です。

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
true
source
Core.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)
true
source
Base.isambiguous — Function
Base.isambiguous(m1, m2; ambiguous_bottom=false)::Bool

2つのメソッド 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)
false
source
Core.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...) と同様です。

Julia 1.12

Method を渡すには Julia 1.12 が必要です。

Passing a CodeInstance instead of a signature

argtypes 引数には CodeInstance を指定できます。この場合、メソッド検索と特殊化の両方が省略されます。この呼び出しの意味は、CodeInstance の invoke ポインターを関数ポインターとして呼び出す場合と同様です。CodeInstance を、その親である MethodInstance に一致しない引数で呼び出した場合、または min_world/max_world の範囲に含まれないワールドエイジから呼び出した場合は、エラーになります。フィールドで指定された制約に動作が適合しない CodeInstance を呼び出した場合の動作は未定義です。owner !== nothing を持つ一部のコードインスタンス(外部コンパイラーが生成したものなど)は、プリコンパイルを経た後に呼び出すとエラーになる場合があります。これは、外部コンパイラープラグインでの使用を想定した高度なインターフェースです。

Julia 1.12

CodeInstance を渡すには Julia 1.12 が必要です。

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)
Integer
source
Base.@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))
Julia 1.7

このマクロを使用するには、Julia 1.7以降が必要です。

Julia 1.9

このマクロはJulia 1.9以降でエクスポートされています。

Julia 1.10

追加の構文はJulia 1.10以降でサポートされています。

source
Base.invokelatest — Function
invokelatest(f, args...; kwargs...)

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

Julia 1.9

Julia 1.9より前は、この関数はエクスポートされておらず、Base.invokelatestとして呼び出されていました。

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

fがグローバル変数の場合、呼び出し先として(最新の)ワールドで一貫して解決されます。ただし、その他のすべての引数(および、リテラルなグローバル変数でない場合はf自体)は、現在のワールドエイジで評価されます。

Julia 1.7

このマクロにはJulia 1.7以降が必要です。

Julia 1.9

Julia 1.9より前のバージョンでは、このマクロはエクスポートされておらず、Base.@invokelatestとして呼び出されていました。

Julia 1.10

追加の構文x.fおよびxs[i]にはJulia 1.10が必要です。

source
new — Keyword
new, or new{A,B,...}

内部コンストラクターで使用できる特殊関数で、その型の新しいオブジェクトを生成します。new{A,B,...}という形式では、パラメトリック型のパラメーター値を明示的に指定します。詳しくは、マニュアルのInner Constructor Methodsを参照してください。

source
Base.:|> — Function
|>(x, f)

引数xに関数fを適用する中置演算子です。これにより、f(g(x))をx |> g |> fと記述できます。無名関数とともに使う場合、意図した連鎖を得るには、通常、関数定義を括弧で囲む必要があります。

Examples

julia> 4 |> inv
0.25

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

julia> [0 1; 2 3] .|> (x -> x^2) |> sum
14
source
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...) も使えます。∘ の最後の引数が最初に実行されます。

Julia 1.4

複数の関数の合成には、Julia 1.4 以降が必要です。

Julia 1.5

1つの関数の合成 ∘(f) には、Julia 1.5 以降が必要です。

Julia 1.7

キーワード引数を使うには、Julia 1.7 以降が必要です。

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

ComposedFunction、!f::Function も参照してください。

source
Base.ComposedFunction — Type
ComposedFunction{Outer,Inner} <: Function

2つの呼び出し可能オブジェクト 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
Julia 1.6

ComposedFunction を使用するには、Julia 1.6 以降が必要です。それ以前のバージョンでは、∘ は代わりに無名関数を返します。

∘ も参照してください。

source
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))
6
source
Base.Fix — Type
Fix{N}(f, x)

関数 f の一部適用版を表す型です。引数 x を位置 N::Int に固定します。つまり、Fix{3}(f, x) は (y1, y2, y3...; kws...) -> f(y1, y2, x, y3...; kws...) と同様に動作します。

Julia 1.12

この汎用機能を使うには Julia 1.12 以降が必要ですが、Fix1 と Fix2 はそれ以前のバージョンでも利用できます。

Note

複数の Fix を入れ子にする場合、Fix{N} における N は、対象関数の引数全体に対する絶対的な順序ではなく、現在利用可能な引数に対する相対的な順序であることに注意してください。たとえば、Fix{1}(Fix{2}(f, 4), 4) は第1引数と第2引数を固定し、Fix{2}(Fix{1}(f, 4), 4) は第1引数と第3引数を固定します。

source
Base.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
42
Julia 1.7

Returns には Julia 1.7 以降が必要です。

source

Syntax

Core.eval — Function
Core.eval(m::Module, expr)

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

source
eval — Function
eval(expr)

式を、それを含むモジュールのグローバルスコープで評価します。baremoduleで定義されたものを除き、すべてのModuleには、モジュール内で使用するために、そのモジュール内の式を評価するevalの非公開の1引数定義があります。

source
Base.@eval — Macro
@eval [mod,] ex

evalを使って、値を式に補間して評価します。引数が2つ指定された場合、1つ目の引数は評価を行うモジュールです。

source
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")
source
Base.esc — Function
esc(e)

マクロから返された Expr のコンテキストでのみ有効です。マクロの衛生化処理によって、埋め込まれた変数が gensym 変数に変換されるのを防ぎます。詳しくは、マニュアルのメタプログラミングの章にある Macros の節を参照してください。

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

@inbounds を使用すると、範囲外のインデックスに対して誤った結果が返されたり、クラッシュやデータ破損が発生したりする可能性があります。手動でのチェックはユーザーの責任です。すべてのアクセスが範囲内であると確信できる場合に限り、@inbounds を使用してください(この前提に違反すると、クラッシュなどの未定義動作が発生する可能性があります)。たとえば、上記のような関数で eachindex(A) の代わりに 1:length(A) を使用しても、安全に範囲内であるとは限りません。A の最初のインデックスは、AbstractArray のサブタイプであるすべてのユーザー定義型で 1 になるとは限らないためです。

source
Base.@boundscheck — Macro
@boundscheck(blk)

式 blk を境界チェックブロックとして注釈し、@inbounds によって省略できるようにします。

Note

@inbounds を有効にするには、@boundscheck が記述されている関数を呼び出し元にインライン化する必要があります。

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

@boundscheck 注釈を付けると、ライブラリの作成者は、@inbounds を使って 他のコード が境界チェックを削除できるようにすることを選択できます。そこで述べられているように、呼び出し元は @inbounds を使う前に、自身が利用できる情報に基づいてアクセスが有効であることを確認する必要があります。たとえば、独自の AbstractArray サブクラスをインデックス指定する場合は、その axes に対してインデックスをチェックします。したがって、@boundscheck 注釈は、getindex または setindex! の実装が正しく動作すると確信できた場合にのみ追加してください。

source
Base.@propagate_inbounds — Macro
@propagate_inbounds

呼び出し元の inbounds コンテキストを保持したまま関数をインライン化するよう、コンパイラに指示します。

source
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
Julia 1.8

関数本体内での使用には、Julia 1.8以降が必要です。


@inline block

block内の呼び出しをインライン化する価値があることを、コンパイラーにヒントとして伝えます。

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

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

呼び出し箇所の注釈は、呼び出される関数の定義に適用された注釈よりも常に優先されます。

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

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

呼び出し箇所の注釈は、そのブロック内のすべての呼び出しに適用されます。呼び出し自体が関数の引数になっている場合も含みます。

# The compiler will not inline `getproperty`, `g` or `f`
@noinline f(x.inner, g(y))
Note

呼び出し箇所の注釈が入れ子になっている場合は、最も内側の注釈が優先されます。

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

呼び出し箇所の注釈は、コストモデルにかかわらずインライン化を強制しようとしますが、成功しない場合もあります。特に、再帰呼び出しは@inlinedとして注釈されていても、インライン化できません。

Julia 1.8

呼び出し箇所の注釈には、Julia 1.8以降が必要です。

source
Base.@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
Julia 1.8

関数本体内での使用には、Julia 1.8以降が必要です。


@noinline block

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

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

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

呼び出し箇所の注釈は、呼び出される関数の定義に適用された注釈よりも常に優先されます。

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

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

呼び出し箇所の注釈が入れ子になっている場合は、最も内側の注釈が優先されます。

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

呼び出し箇所の注釈には、Julia 1.8以降が必要です。


Note

関数が単純な場合(たとえば、定数を返すだけの場合)は、それでもインライン化されることがあります。

source
Base.@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
Note

@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 の呼び出し元を最適化する際にも引き続き使われます。

source
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}) の推論が実行されたことを示しています。

Julia 1.10

Base.@nospecializeinfer を使用するには、Julia 1.10 以降が必要です。

source
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
    ...
end
Julia 1.10

関数本体内で使用するには、Julia 1.10以降が必要です。

source
Base.gensym — Function
gensym([tag])

(同じモジュール内の)ほかの変数名と衝突しないシンボルを生成します。

source
Base.@gensym — Macro
@gensym

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

source
var"name" — Keyword
var

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

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

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

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

Julia 1.3

この構文を使用するには、Julia 1.3 以降が必要です。

source
Base.@goto — Macro
@goto name

@goto name は、@label name の位置にある文へ無条件にジャンプします。

@label と @goto では、異なるトップレベルの文へのジャンプを作成できません。これを試みるとエラーになります。それでも @goto を使用するには、@label と @goto をブロックで囲みます。

source
Base.@label — Macro
@label name

文に記号ラベル name を付けます。このラベルは、@goto name を伴う無条件ジャンプの終点を示します。

source
Base.SimdLoop.@simd — Macro
@simd

コンパイラーがループの順序を入れ替えられるよう、for ループに注釈を付けて、より自由に最適化できるようにします。

Warning

この機能は実験的なものであり、今後の Julia のバージョンで変更または削除される可能性があります。@simd マクロを誤って使用すると、予期しない結果を招くことがあります。

@simd for ループで反復処理する対象は、1 次元の範囲である必要があります。@simd を使用すると、ループについて次の性質を満たすことを表明します。

  • リダクション変数に特別な配慮をしたうえで、反復を任意の順序、または重複する順序で安全に実行できる。
  • リダクション変数に対する浮動小数点演算の順序を入れ替えたり、演算を融合したりできる。その結果、@simd を使用しない場合とは異なる結果になる可能性がある。

多くの場合、Julia は @simd を使わなくても、内側の for ループを自動的にベクトル化できます。@simd を使うと、より多くの状況でベクトル化できるよう、コンパイラーに多少の裁量を与えられます。どちらの場合も、内側のループをベクトル化するには、次の性質が必要です。

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

@simd は、デフォルトではループ伝搬メモリー依存が完全に存在しないことを表明しません。これは汎用コードでは簡単に破られうる前提です。汎用でないコードを書く場合は、@simd ivdep for ... end を使って、次の点も表明できます。

  • ループ伝搬メモリー依存が存在しない。
  • 反復が、前の反復による進行を待つことがない。
source
Base.@polly — Macro
@polly

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

source
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"
source
Base.@assume_effects — Macro
Base.@assume_effects setting... [ex]

コンパイラーのエフェクト解析をオーバーライドします。このマクロは、次のような複数のコンテキストで使用できます。

  1. メソッド定義の直前に置き、対象メソッドのエフェクト解析全体をオーバーライドする。
  2. 引数なしで関数本体内に置き、包含するメソッドのエフェクト解析全体をオーバーライドする。
  3. コードブロックに適用し、対象コードブロックのローカルなエフェクト解析をオーバーライドする。

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}
Julia 1.8

Base.@assume_effects を使用するには、Julia 1.8 以降が必要です。

Julia 1.10

関数本体内で使用するには、Julia 1.10 以降が必要です。

Julia 1.11

コードブロックの注釈には、Julia 1.11 以降が必要です。

Warning

このマクロを不適切に使用すると、未定義動作(クラッシュ、誤った結果、その他追跡が困難なバグを含む)が発生します。慎重に扱い、絶対に必要な場合の最後の手段としてのみ使用してください。その場合でも、エフェクトのアサーションをできる限り弱めるためのあらゆる手段を講じるべきです(たとえば、: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 である。
Note

これは特に、メソッドが新たに割り当てた可変オブジェクトを返してはならないことを意味します。可変オブジェクトを複数回割り当てた場合、内容が同一でも egal ではありません。

Note

: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 関数は、指定されたワールドエイジ範囲内で一定でないヒープの状態やその他のグローバル状態に依存して戻り値を決めてはならないことも意味します。

Note

:consistent-cy には、オプティマイザーが行うすべての合法な書き換えが含まれます。たとえば、浮動小数点数に対する fastmath 演算は :consistent とは見なされません。オプティマイザーが書き換えを行うと、同じワールドエイジであっても出力が :consistent でなくなる可能性があるためです(たとえば、一方がインタープリターで実行され、もう一方が最適化されて実行された場合)。

Note

:consistent 関数が例外を投げて終了する場合、その例外自体は、上記の egal 性の要件を満たす必要はありません。


:effect_free

:effect_free の設定は、メソッドに外部から意味的に観測可能な副作用がないことをアサートします。外部から意味的に観測可能な副作用の例を以下に示します(ただし、これらに限りません)。

  • グローバル変数の値を変更する。
  • 以下に記載する場合を除き、ヒープ(配列や可変値など)を変更する。
  • メソッドテーブルを変更する(たとえば、eval の呼び出しによる変更)。
  • ファイル、ネットワークなどへの入出力。
  • タスクの切り替え。

一方、観測可能な場合があっても、次のものは意味的に観測可能な副作用とは明示的に見なされません。

  • メモリの割り当て(可変・不変の両方)。
  • 経過時間。
  • ガベージコレクション。
  • メソッドの実行期間を超えて存続しないオブジェクト(つまり、メソッド内で割り当てられ、外部に逃げないオブジェクト)のヒープ変更。
  • 戻り値(外部からは見えますが、副作用ではありません)。

目安としては、関数が実行されなかった場合にプログラムの残りの実行に影響するものは、外部から観測可能な副作用です。

Note

:effect_free アサーションは、メソッド自体と、そのメソッドによって実行されるすべてのコードに対して適用されます。このアサーションはすべてのワールドエイジで有効でなければならないため、使用は適切に制限してください。


:nothrow

:nothrow の設定は、このメソッドが例外を投げないこと(つまり、値を返すか、戻らないかのいずれかであること)をアサートします。

Note

:nothrow の注釈が付いたメソッドでも、例外をメソッドの外へ再送出しない限り、内部で例外処理を使用できます。

Note

メソッドの実行によって MethodError などの例外が発生する可能性がある場合、そのメソッドは :nothrow とは見なされません。ただし、StackOverflowError や InterruptException のような環境依存のエラーは、このエフェクトではモデル化されません。そのため、StackOverflowError になる可能性のあるメソッドが、必ずしも !:nothrow である必要はありません(ただし、通常は !:terminates でもあるべきです)。


:terminates_globally

:terminates_globally の設定は、このメソッドが最終的に(正常または異常に)終了し、無限ループしないことをアサートします。

Note

この :terminates_globally アサーションは、注釈対象のメソッドが呼び出す他のすべてのメソッドにも適用されます。

Note

コンパイラーは、この設定をメソッドが比較的速く終了する強い根拠と見なし、(他の条件が許せば)コンパイル時にこのメソッドを呼び出すことがあります。つまり、技術的には終了するものの、実用上は終了しないようなメソッドにこの設定を付けるのは得策ではありません。


:terminates_locally

:terminates_locally の設定は :terminates_globally と似ていますが、注釈対象メソッド内の構文上の制御フローにのみ適用されます。そのため、より弱く安全性の高いアサーションであり、終了しない別のメソッドを呼び出した場合には、注釈対象メソッド自体が終了しない可能性を許容します。

Note

:terminates_globally は :terminates_locally を含意します。


:notaskstate

:notaskstate の設定は、このメソッドがタスクローカルストレージや RNG の状態など、ローカルなタスク状態を使用も変更もしないことをアサートします。そのため、観測可能な結果を変えることなく、タスク間で安全に移動できます。

Note

例外処理の実装では、タスクオブジェクトに保存された状態を使用します。ただし、この状態は現在 :notaskstate の対象範囲とは見なされず、:nothrow エフェクトによって別途追跡されます。

Note

:notaskstate アサーションが対象とするのは、現在実行中のタスクの状態です。どのタスクが現在実行中かを考慮しない別の手段で Task オブジェクトへの参照を取得した場合、:notaskstate エフェクトは汚染されないことがあります。そのタスクオブジェクトが現在実行中のタスクに対して === であっても同様です。

Note

タスク状態へのアクセスは、通常、他のエフェクトも汚染します。たとえば、タスク状態を変更する場合は :effect_free、結果の計算にタスク状態を使用する場合は :consistent が汚染されます。特に、:notaskstate ではないものの、:effect_free かつ :consistent であるコードは、依然としてデッドコード除去の対象となり、:total に昇格することがあります。


:inaccessiblememonly

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

Note

この前提を無効にする例を以下に示します(ただし、これらに限りません)。

  • グローバル参照、または可変なグローバル変数にアクセスする getglobal 呼び出し。
  • グローバルへの代入、または定数でないグローバル変数に代入する setglobal! 呼び出し。
  • グローバルな可変変数のフィールドを変更する setfield! 呼び出し。
Note

この :inaccessiblememonly アサーションは、注釈対象のメソッドが呼び出す他のすべてのメソッドにも適用されます。


:noub

:noub の設定は、このメソッドが(どのような入力に対しても)未定義動作を実行しないことをアサートします。未定義動作によって、:consistent や :effect_free など、他のエフェクトに関するアサーションにも違反する可能性はあります。しかし、これはモデル化されておらず、各エフェクトは未定義動作がないことを前提としています。


:nortcall

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

Note

厳密には、実行時に 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
Note

このリストには、特に :nothrow が含まれていません。コンパイラーは引き続き定数伝播を試み、コンパイル時に発生したエラーを記録します。ただし、:consistent-cy の要件により、この注釈が付いた呼び出しは、同じ引数値に対して常に一貫して例外を投げなければなりません。

Note

関数内に明示的な @inbounds 注釈がある場合も、定数畳み込みは無効になります。この注釈は :foldable によってオーバーライドされません。


:removable

この設定は、コンパイル時に結果が使われない呼び出しを確実に除去するためにコンパイラーが必要とするエフェクト一式を、簡潔に指定するものです。現在は、次の setting と同等です。

  • :effect_free
  • :nothrow
  • :terminates_globally

:total

この setting は、可能な限り最大のエフェクト集合です。現在、次の他の setting を含意します。

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

:total は非常に強いアサーションであり、Julia の将来のバージョンでは追加の意味が加わる可能性があります(たとえば、エフェクトが追加され、:total の定義に含まれる場合)。そのため、慎重に使用してください。可能な限り、用途に必要な最小限の具体的なエフェクトアサーションを使用してください。多数のエフェクトのオーバーライドを複数の関数に適用する場合は、:total を使うより、カスタムマクロを使うことをお勧めします。


Negated effects

エフェクト名の前に ! を付けると、先行するメタエフェクトからそのエフェクトを取り除くことを示せます。たとえば、:total !:nothrow は、呼び出しが一般には全域的である一方、例外を投げる可能性があることを示します。

source

Managing deprecations

Base.@deprecate — Macro
@deprecate old new [export_old=true]

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

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

関連項目: Base.depwarn()。

Julia 1.5

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

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) は定義も非推奨化もされません。

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

Missing Values

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)
missing
source
Base.@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
[...]
Julia 1.7

このマクロはJulia 1.7以降で利用できます。

source
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
 2
source
Base.nonmissingtype — Function
nonmissingtype(T::Type)

T が Missing を含む型のユニオンである場合、Missing を取り除いた新しい型を返します。

Examples

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

julia> nonmissingtype(Any)
Any
Julia 1.3

この関数は Julia 1.3 以降でエクスポートされています。

source

System

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。

source
Base.devnull — Constant
devnull

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

run(pipeline(`cat test.txt`, devnull))
source
Base.success — Function
success(command)

バッククォートで構築したコマンドオブジェクト(マニュアルのRunning External Programsのセクションを参照)を実行し、成功したかどうか(終了コードが0かどうか)を判定します。プロセスを起動できない場合は例外が発生します。

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

プロセスにシグナルを送信します。デフォルトではプロセスを終了します。プロセスがすでに終了している場合は正常に戻りますが、権限不足など、ほかの理由でプロセスの終了に失敗した場合はエラーをスローします。

source
Base.Sys.set_process_title — Function
Sys.set_process_title(title::AbstractString)

プロセスのタイトルを設定します。一部のオペレーティングシステムでは何も行いません。

source
Base.Sys.get_process_title — Function
Sys.get_process_title()

プロセスのタイトルを取得します。一部のシステムでは、常に空文字列が返されます。

source
Base.ignorestatus — Function
ignorestatus(command)

コマンドオブジェクトに印を付け、実行結果のコードがゼロ以外でもエラーが発生しないようにします。

source
Base.detach — Function
detach(command)

コマンドオブジェクトに印を付け、新しいプロセスグループで実行されるようにします。これにより、Julia プロセスの終了後も実行を続けられ、Ctrl-C による割り込みも渡されません。

source
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)
source
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 です(まだ指定されていない場合は、現在の作業ディレクトリになります)。

関連項目: Cmd、addenv、ENV、pwd。

source
Base.addenv — Function
addenv(command::Cmd, env...; inherit::Bool = true)

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

Cmd、setenv、ENVも参照してください。

Julia 1.6

この関数を使用するには、Julia 1.6以降が必要です。

source
Base.withenv — Function
withenv(f, kv::Pair...)

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

Warning

環境の変更はスレッドセーフではありません。親プロセスとは異なる環境で外部コマンドを実行する場合は、addenvをwithenvよりも優先して使用してください。

source
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"
source
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"
source
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"
source
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_posixly()

source
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))
Warning

バッチファイルを呼び出す際に CMD が行う引数解析(.bat ファイル内での呼び出し、およびバッチファイルへの引数としての呼び出し)は、この関数の出力と完全には互換性がありません。特に、% の処理方法が異なります。

Important

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^\""
source
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() も参照してください。

source
Base.setcpuaffinity — Function
setcpuaffinity(original_command::Cmd, cpus) -> command::Cmd

command の CPU アフィニティを、CPU ID(1 始まり)のリスト cpus で設定します。cpus = nothing を渡すと、original_command に CPU アフィニティが設定されている場合、それを解除します。

この関数は Linux と Windows でのみサポートされています。libuv がアフィニティの設定をサポートしていないため、macOS では利用できません。

Julia 1.8

この関数を使用するには、Julia 1.8 以降が必要です。

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
0x13
source
Base.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`))
source
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))
source
Base.Libc.getpid — Function
getpid()::Int32

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

source
getpid(process)::Int32

子プロセスがまだ存在する場合は、そのプロセス ID を取得します。

Julia 1.1

この関数を使用するには、Julia 1.1 以降が必要です。

source
Base.Libc.time — Method
time()::Float64

エポックからの経過秒数でシステム時刻を取得します。比較的高い精度(通常はマイクロ秒単位)で取得できます。

time_ns

source
Base.time_ns — Function
time_ns()::UInt64

システム固有の任意の過去の時点を基準とした、ナノ秒単位の時刻を取得します。主な用途は、プログラムの実行中に経過時間を測定することです。返される値は、システムの稼働中は単調増加することが保証されています(2⁶⁴を法とする)。また、クロックのドリフトやローカルの暦時刻の変更の影響を受けません。ただし、システムの再起動やサスペンドをまたぐと、値が任意に変化することがあります。

(返される時刻は常にナノ秒単位ですが、時間分解能はプラットフォームによって異なります。)

source
Base.@time — Macro
@time expr
@time "description" expr

式を実行し、その実行にかかった時間、割り当て回数、および実行によって割り当てられた総バイト数を表示してから、式の値を返すマクロです。ガベージコレクション(gc)、新しいコードのコンパイル、または無効化されたコードの再コンパイルにかかった時間は、割合として表示されます。ReentrantLockが待機する必要のあったロック競合は、件数で表示されます。

時間のレポートの前に表示する説明文字列を、任意で指定できます。

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

関連項目:@showtime、@timev、@timed、@elapsed、@allocated、@allocations。

Note

より本格的なベンチマークには、BenchmarkTools.jlパッケージの@btimeマクロを検討してください。このマクロは、ノイズを抑えるために関数を複数回評価するなどの処理を行います。

Julia 1.8

説明を追加するオプションは、Julia 1.8で導入されました。

再コンパイル時間をコンパイル時間とは別に表示する機能は、Julia 1.8で導入されました。

Julia 1.11

ロック競合の件数を報告する機能は、Julia 1.11で追加されました。

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)
source
Base.@showtime — Macro
@showtime expr

@timeと似ていますが、参照用に評価対象の式も出力します。

Julia 1.8

このマクロはJulia 1.8で追加されました。

関連項目: @time。

julia> @showtime sleep(1)
sleep(1): 1.002164 seconds (4 allocations: 128 bytes)
source
Base.@timev — Macro
@timev expr
@timev "description" expr

これは、@time マクロの詳細版です。まず @time と同じ情報を出力し、続いてゼロ以外のメモリ割り当てカウンターを出力した後、式の値を返します。

必要に応じて、時間レポートの前に出力する説明文字列を指定できます。

Julia 1.8

説明を追加するオプションは Julia 1.8 で導入されました。

関連項目: @time、@timed、@elapsed、@allocated、@allocations。

julia> x = rand(10,10);

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

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1
source
Base.@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
Julia 1.5

このマクロの戻り値の型は、Julia 1.5でTupleからNamedTupleに変更されました。

Julia 1.11

lock_conflicts、compile_time、recompile_timeフィールドは、Julia 1.11で追加されました。

source
Base.@elapsed — Macro
@elapsed

式を評価し、実行にかかった秒数を浮動小数点数で返します。評価結果の値は破棄されます。

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

@time、@timev、@timed、@allocated、@allocationsも参照してください。

julia> @elapsed sleep(0.3)
0.301391426
source
Base.@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)
8000080
source
Base.@allocations — Macro
@allocations

式を評価し、その結果の値を破棄して、式の評価中に発生した割り当ての総数を返すマクロです。

関連項目: @allocated、@time、@timev、@timed、@elapsed。

julia> @allocations rand(10^6)
2
Julia 1.9

このマクロは Julia 1.9 で追加されました。

source
Base.@lock_conflicts — Macro
@lock_conflicts

式を評価してその結果を破棄し、代わりに評価中に発生したロック競合の総数を返すマクロです。ロックがすでに保持されていたため、ReentrantLockへのロック取得が待機状態になった場合に、ロック競合として数えます。

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

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

このマクロはJulia 1.11で追加されました。

source
Base.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 オプション)。

source
Base.EnvDict — Type
EnvDict()::EnvDict

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

source
Base.ENV — Constant
ENV

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

(Windowsでは、システム環境変数の大文字と小文字は区別されません。そのため、ENVは、表示、反復処理、コピーの際にすべてのキーを大文字に変換します。移植性のあるコードでは、大文字と小文字の違いによって変数を区別できることを前提にしないでください。また、小文字で指定したつもりの変数を設定すると、キーが大文字のENVになる場合があることにも注意してください。)

Warning

環境変数の変更はスレッドセーフではありません。

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"

関連項目:withenv、addenv。

source
Base.Sys.STDLIB — Constant
Sys.STDLIB::String

stdlib パッケージが格納されているディレクトリのフルパスを表す文字列。

source
Base.Sys.isbsd — Function
Sys.isbsd([os])

OSがBSDの派生系かどうかを判定する述語です。詳しくはHandling Operating System Variationを参照してください。

Note

DarwinカーネルはBSDを起源としているため、macOSではSys.isbsd()はtrueになります。述語の対象からmacOSを除外するには、Sys.isbsd() && !Sys.isapple()を使用してください。

source
Base.Sys.isfreebsd — Function
Sys.isfreebsd([os])

OS が FreeBSD 派生かどうかを判定する述語です。Handling Operating System Variation のドキュメントを参照してください。

Note

Sys.isbsd() と混同しないでください。これは FreeBSD だけでなく、ほかの BSD ベースのシステムでも true になります。Sys.isfreebsd() は FreeBSD のみを対象とします。

Julia 1.1

この関数には Julia 1.1 以降が必要です。

source
Base.Sys.isopenbsd — Function
Sys.isopenbsd([os])

OSがOpenBSDの派生版かどうかを判定する述語です。ドキュメントはHandling Operating System Variationを参照してください。

Note

Sys.isbsd()と混同しないでください。これはOpenBSDだけでなく、ほかのBSD系システムでもtrueです。Sys.isopenbsd()が指すのはOpenBSDのみです。

Julia 1.1

この関数を使用するには、Julia 1.1以降が必要です。

source
Base.Sys.isnetbsd — Function
Sys.isnetbsd([os])

OSがNetBSDの派生OSかどうかを判定する述語です。詳細はHandling Operating System Variationを参照してください。

Note

Sys.isbsd()と混同しないでください。NetBSDだけでなく、ほかのBSD系システムでもtrueです。Sys.isnetbsd()が指すのはNetBSDのみです。

Julia 1.1

この関数を使用するには、Julia 1.1以降が必要です。

source
Base.Sys.isdragonfly — Function
Sys.isdragonfly([os])

OS が DragonFly BSD の派生であるかどうかを判定する述語です。Handling Operating System Variation のドキュメントを参照してください。

Note

Sys.isbsd() と混同しないでください。これは DragonFly だけでなく、他の BSD ベースのシステムでも true になります。Sys.isdragonfly() は DragonFly のみを対象とします。

Julia 1.1

この関数には Julia 1.1 以降が必要です。

source
Base.Sys.windows_version — Function
Sys.windows_version()

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

source
Base.Sys.total_memory — Function
Sys.total_memory()

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

source
Base.Sys.free_physical_memory — Function
Sys.free_physical_memory()

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

source
Base.Sys.total_physical_memory — Function
Sys.total_physical_memory()

RAMの総メモリ容量(現在使用中の分を含む)をバイト単位で取得します。その全容量を現在のプロセスで利用できるとは限りません。Sys.total_memory()。

source
Base.Sys.uptime — Function
Sys.uptime()

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

source
Base.Sys.sysimage_target — Function
Sys.sysimage_target()

現在のシステムイメージのビルドに使用された CPU ターゲット文字列を返します。

この関数は、システムイメージのコンパイル時に Julia に渡された元の CPU ターゲット指定を返します。同じシステムイメージを再現したり、コンパイル時に有効になっていた CPU 機能を確認したりする際に役立ちます。

システムイメージがデフォルト設定でビルドされている場合は、"native" を返します。

関連項目: JULIA_CPU_TARGET。

source
Base.Sys.isjsvm — Function
Sys.isjsvm([os])

Julia が JavaScript VM(JSVM)上で実行されているかどうかを判定する述語です。たとえば、Web ブラウザーに組み込まれた WebAssembly JavaScript 環境などが該当します。

Julia 1.2

この関数を使用するには、Julia 1.2 以降が必要です。

source
Base.Sys.loadavg — Function
Sys.loadavg()

ロードアベレージを取得します。詳細は https://en.wikipedia.org/wiki/Load_(computing). を参照してください。

source
Base.Sys.isexecutable — Function
isexecutable(path::String)

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

Note

ユーザーがpathを実行する前に、この権限が変更される可能性があります。そのため、先にisexecutableを呼び出すよりも、ファイルを実行し、失敗した場合はエラーを処理することを推奨します。

Note

Julia 1.6より前のバージョンでは、Windows上のファイルシステムACLを正しく調べられなかったため、どのファイルに対してもtrueを返していました。Julia 1.6以降では、ファイルに実行可能属性が設定されているかどうかを正しく判定します。

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

source
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")
source
isreadable(path::String)

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

Note

ユーザーがopenを呼び出す前に、この権限が変更される可能性があります。そのため、まずisreadableを呼び出すよりも、openだけを呼び出し、失敗した場合はエラーを処理することを推奨します。

Note

現在、この関数はWindows上のファイルシステムACLを正しく調べられないため、誤った結果を返すことがあります。

Julia 1.11

この関数を使用するには、Julia 1.11以降が必要です。

関連項目:ispath、isexecutable、iswritable。

source
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")
source
iswritable(path::String)

指定されたpathへのアクセス権限で現在のユーザーによる書き込みが許可されている場合、trueを返します。

Note

ユーザーがopenを呼び出す前に、この権限が変更される可能性があります。そのため、まずiswritableを呼び出すのではなく、openだけを呼び出し、失敗した場合はエラーを処理することをお勧めします。

Note

現在、この関数はWindows上のファイルシステムACLを正しく照会できないため、誤った結果を返すことがあります。

Julia 1.11

この関数を使用するには、Julia 1.11以降が必要です。

関連項目: ispath、isexecutable、isreadable。

source
Base.Sys.which — Function
Sys.which(program_name::String)

プログラム名を指定すると、現在の PATH を検索し、実行権限が適切に設定されていて実行可能な最初のバイナリを見つけて、その絶対パスを返します。そのようなプログラムが見つからない場合は、nothing を返します。program_name にディレクトリを含むパスを指定した場合は、そのパス自体について実行権限のみを確認します(Windows プラットフォームでは .exe と .com の拡張子を追加して確認します)。PATH の検索は行いません。

source
Base.Sys.username — Function
Sys.username()::String

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

環境変数で上書きできるユーザー名を取得するには、たとえば USER を使用してください。

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

この関数を使用するには、Julia 1.11 以降が必要です。

関連項目: homedir。

source
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となります。

source

Versioning

Base.VersionNumber — Type
VersionNumber

semantic versioning (semver)の仕様に従うバージョン番号型です。メジャー、マイナー、パッチの数値に続いて、プレリリースおよびビルドを示す英数字の注釈で構成されます。

VersionNumberオブジェクトは、標準の比較演算子(==、<、<=など)で比較できます。比較結果はsemver v2.0.0-rc.2の規則に従います。

VersionNumberには、次のパブリックフィールドがあります。

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

semver形式のリテラル文字列からVersionNumberオブジェクトを効率よく構築するには@v_strを、Julia自体のVersionNumberについてはVERSIONを、マニュアルについては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"
false
source
Base.@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"
source

Errors

Base.error — Function
error(msg...)

ErrorExceptionを、string(msg...)で構成したメッセージとともに発生させます。

source
error(message::AbstractString)

指定したメッセージでErrorExceptionを発生させます。

source
Base.rethrow — Function
rethrow()

catch ブロック内で、現在の例外を再スローします。再スローされた例外は、捕捉されなかった場合と同様に伝播を続けます。

Note

もう一つの形式である rethrow(e) を使うと、現在のバックトレースに別の例外オブジェクト e を関連付けられます。ただし、これはエラー発生時のプログラムの状態を正しく表さないため、代わりに throw(e) を使って新しい例外をスローすることをお勧めします。Julia 1.1 以降では、throw(e) を使うと、current_exceptions で説明されているように、根本原因となった例外がスタック上に保持されます。

source
Base.backtrace — Function
backtrace()

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

source
Base.catch_backtrace — Function
catch_backtrace()

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

source
Base.current_exceptions — Function
current_exceptions(task::Task=current_task(); [backtrace::Bool=true])

現在処理中の例外スタックを取得します。入れ子になった catch ブロックでは、現在の例外が複数存在する場合があります。その場合、最後にスローされた例外がスタックの末尾にあります。スタックは、名前付きタプル (exception,backtrace) の AbstractVector である ExceptionStack として返されます。backtrace が false の場合、各ペアのバックトレースは nothing に設定されます。

task を明示的に渡すと、任意のタスクの現在の例外スタックを取得できます。これは、捕捉されない例外によって失敗したタスクを調べるのに便利です。

Julia 1.7

この関数は Julia 1.1~1.6 では実験的な名前 catch_stack() で呼ばれており、戻り値の型は単純なタプルの Vector でした。

source
Base.@assert — Macro
@assert cond [text]

AssertionError を使うと、cond が false の場合に例外をスローします。これはアサーションを記述するための推奨構文です。アサーションとは、真であると想定される条件のことで、失敗した場合にデバッグの助けとしてユーザーが確認できます。省略可能なメッセージ text は、アサーションが失敗したときに表示されます。

Warning

最適化レベルによっては、アサーションが無効になることがあります。そのため、アサーションはデバッグ用のツールとしてのみ使用し、認証の検証(パスワードの確認や配列の境界チェックなど)には使用しないでください。関数が正しく動作するために、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?"
source
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:
    ...
Julia 1.5

独自のエラーヒントは Julia 1.5 以降で利用できます。

Warning

このインターフェースは実験的なものであり、予告なく変更または削除される可能性があります。変更の影響を受けにくくするには、登録処理を if isdefined(Base.Experimental, :register_error_hint) ... end ブロック内に記述することを検討してください。

source
Base.Experimental.show_error_hints — Function
Experimental.show_error_hints(io, ex, args...)

特定の例外型 typeof(ex) とそのすべてのスーパータイプについて、Experimental.register_error_hint のすべてのハンドラーを呼び出します。args には、その型のハンドラーが必要とするその他の引数をすべて指定してください。

Julia 1.5

カスタムエラーヒントは Julia 1.5 以降で利用できます。

Warning

このインターフェースは実験的なものであり、予告なく変更または削除される場合があります。

source
Core.ArgumentError — Type
ArgumentError(msg)

関数に渡された引数が無効です。msg は、エラーの内容を説明するメッセージです。

source
Core.AssertionError — Type
AssertionError([msg])

アサートされた条件の評価結果が true ではありませんでした。省略可能な引数 msg は、エラーを説明する文字列です。

Examples

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

AssertionError は通常、@assert からスローされます。

source
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]
source
Base.CompositeException — Type
CompositeException

Task が投げた例外(たとえば、チャネル経由でリモートワーカーから送られた例外や、非同期で実行されるローカル I/O 書き込み、または pmap 上のリモートワーカーから送られた例外)を Vector でラップし、一連の例外に関する情報を付加します。たとえば、複数のワーカーがいくつかのタスクを実行していて、そのうち複数のワーカーで失敗が発生した場合、結果として得られる CompositeException には、例外がどこで、なぜ発生したかを示す各ワーカーからの情報が「束ねられて」含まれます。

source
Base.DimensionMismatch — Type
DimensionMismatch([msg])

呼び出されたオブジェクトの次元が一致していません。省略可能な引数 msg は、エラーを説明する文字列です。

source
Core.DivideError — Type
DivideError()

分母の値が 0 の状態で整数除算が試みられました。

Examples

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: integer division error
Stacktrace:
[...]
source
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:
[...]
source
Base.EOFError — Type
EOFError()

ファイルまたはストリームから読み取れるデータはこれ以上ありませんでした。

source
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"
source
Core.FieldError — Type
FieldError(type::DataType, field::Symbol)

オブジェクト type の無効な field にアクセスしようとしました。

Julia 1.12

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:
[...]
source
Core.InexactError — Type
InexactError(name::Symbol, T, val)

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

Examples

julia> convert(Float64, 1+2im)
ERROR: InexactError: Float64(1 + 2im)
Stacktrace:
[...]
source
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がスローされます。

source
Base.KeyError — Type
KeyError(key)

AbstractDict(Dict)やSetのようなオブジェクトに対するインデックス操作で、存在しない要素にアクセスまたは削除しようとしました。

source
Core.LoadError — Type
LoadError(file::AbstractString, line::Int, error)

ファイルのinclude、require、またはusing中にエラーが発生しました。エラーの詳細は.errorフィールドに記載されています。

Julia 1.7

Julia 1.7以降、@macroexpand、@macroexpand1、macroexpandではLoadErrorsは発生しなくなりました。

source
Core.MethodError — Type
MethodError(f, args)

指定されたジェネリック関数に、要求された型シグネチャを持つメソッドが存在しません。または、最も具体的なメソッドが一意に定まりません。

source
Base.MissingException — Type
MissingException(msg)

サポートされていない状況でmissingの値が検出されたときにスローされる例外です。msgフィールドのエラーメッセージに、より詳しい情報が記載されている場合があります。

source
Core.OutOfMemoryError — Type
OutOfMemoryError()

システムまたはガベージコレクターが適切に処理できる量を超えるメモリを、操作によって割り当てました。

source
Core.OverflowError — Type
OverflowError(msg)

式の結果が指定された型で表現できる範囲を超えているため、オーバーフローが発生します。

source
Base.ProcessFailedException — Type
ProcessFailedException

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

source
Base.TaskFailedException — Type
TaskFailedException

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

source
Core.StackOverflowError — Type
StackOverflowError()

関数呼び出しがコールスタックのサイズを超えました。通常、これは呼び出しが無限に再帰している場合に発生します。

source
Base.SystemError — Type
SystemError(prefix::AbstractString, [errno::Int32])

システムコールがエラーコードで失敗しました(errno グローバル変数内)。

source
Core.TypeError — Type
TypeError(func::Symbol, context::AbstractString, expected::Type, got)

型アサーションの失敗、または不正な型の引数を指定して組み込み関数を呼び出した場合。

source
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]:1
source
Core.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:
[...]
source
Core.UndefVarError — Type
UndefVarError(var::Symbol, [scope])

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

Examples

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

julia> a = 1;

julia> a
1
source
Base.StringIndexError — Type
StringIndexError(str, i)

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

source
Core.InitError — Type
InitError(mod::Symbol, error)

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

source
Base.retry — Function
retry(f;  delays=ExponentialBackOff(), check=nothing) -> Function

f 関数を呼び出す無名関数を返します。例外が発生した場合、check が true を返すたびに、delays で指定された秒数だけ待機してから、f が繰り返し再度呼び出されます。check は、delays の現在の状態と Exception を入力として受け取ります。

Julia 1.2

Julia 1.2 より前では、このシグネチャは f::Function に限定されていました。

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)
source
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 に制限されます。

source

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 されます。

Julia 1.12

spawn 引数は Julia 1.12 で導入されました。

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
3
source
Base.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)
false
Note

interval では、時間のずれが累積することがあります。特定の絶対時刻に正確なイベントを発生させる必要がある場合は、各回の期限が来るたびに、次の時刻までの差分を計算して新しいタイマーを作成してください。

Note

Timer の状態を更新するには、yield ポイントが必要です。たとえば、yield しない while ループのタイムアウトに isopen(t::Timer) を使用することはできません。

!!! compat "Julia 1.12 timeout と interval の読み取り可能なプロパティは、Julia 1.12 で追加されました。

source
Base.AsyncCondition — Type
AsyncCondition()

Cからuv_async_sendを呼び出して通知すると、待機中のタスクを起こす非同期条件を作成します(オブジェクトに対してwaitを呼び出します)。オブジェクトを閉じると(closeを呼び出すと)、待機中のタスクはエラーで起こされます。引き続き有効かどうかはisopenで確認できます。閉じられた条件は無効となり、タスクを起こしません。

これにより、送信側スレッドと待機側スレッドの間に、暗黙的な acquire/release メモリ順序が確立されます。

source
Base.AsyncCondition — Method
AsyncCondition(callback::Function)

指定されたcallback関数を呼び出す非同期条件を作成します。callbackには、非同期条件オブジェクト自体が引数として1つ渡されます。

source

Reflection

Base.nameof — Method
nameof(m::Module)::Symbol

Module の名前を Symbol として取得します。

Examples

julia> nameof(Base.Broadcast)
:Broadcast
source
Base.parentmodule — Function
parentmodule(m::Method)::Module

指定したメソッド m が定義されているモジュールを返します。

Julia 1.9

引数として Method を渡すには、Julia 1.9 以降が必要です。

source
parentmodule(f::Function, types)::Module

指定されたtypesに一致する、ジェネリック関数fの最初のメソッドを含むモジュールを特定します。

source
parentmodule(f::Function)::Module

ジェネリック関数の(最初の)定義を含むモジュールを特定します。

source
parentmodule(t::DataType)::Module

(UnionAllで囲まれている可能性のある)DataTypeの定義を含むモジュールを特定します。

Examples

julia> module Foo
           struct Int end
       end
Foo

julia> parentmodule(Int)
Core

julia> parentmodule(Foo.Int)
Foo
source
parentmodule(m::Module)::Module

モジュールを囲むModuleを取得します。Mainは、それ自体が親です。

関連項目: names、nameof、fullname、@__MODULE__。

Examples

julia> parentmodule(Main)
Main

julia> parentmodule(Base.Broadcast)
Base
source
Base.pathof — Method
pathof(m::Module)

m.jl ファイルのパスを返します。このファイルは import モジュール m の読み込みに使用されたものです。m がパッケージからインポートされていない場合は、nothing を返します。

パスのディレクトリ部分を取得するには dirname を、ファイル名部分を取得するには basename を使用してください。

pkgdir も参照してください。

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

Julia 1.7

オプション引数 paths を使用するには、Julia 1.7 以降が必要です。

source
Base.pkgversion — Method
pkgversion(m::Module)

モジュール m がバージョン管理されたパッケージに属している場合は、そのパッケージのバージョン番号を返します。そうでない場合は、nothing を返します。

バージョンは、パッケージの読み込み時に、そのパッケージの Project.toml から読み取られます。

現在のモジュールをインポートしたパッケージのバージョンを取得するには、pkgversion(@__MODULE__) という形式を使用できます。

Julia 1.9

この関数は Julia 1.9 で導入されました。

source
Base.moduleroot — Function
moduleroot(m::Module)::Module

指定されたモジュールのルートモジュールを検索します。これは、m の親モジュールをたどったときに、登録済みのルートモジュールであるか、自身を親モジュールとする最初のモジュールです。

source
__module__ — Keyword
__module__

引数 __module__ はマクロ内でのみ参照でき、マクロ呼び出しの展開コンテキストに関する情報を(Module オブジェクトの形式で)提供します。詳しくは、Macro invocation のマニュアルの節を参照してください。

source
__source__ — Keyword
__source__

引数 __source__ はマクロ内でのみ参照でき、マクロ呼び出しにおける @ 記号のパーサー上の位置に関する情報を、LineNumberNode オブジェクトとして提供します。詳しくは、マニュアルの Macro invocation の節を参照してください。

source
Base.@__MODULE__ — Macro
@__MODULE__ -> Module

トップレベルの評価で使用されているModuleを取得します。これは、現在コードを読み込んでいるModuleです。

source
Base.@__FUNCTION__ — Macro
@__FUNCTION__

最も内側で囲んでいる関数オブジェクトを取得します。

Note

@__FUNCTION__のスコープ動作はreturnと同じです。クロージャ内で使うと、外側の関数ではなくクロージャを参照します。@spawnや@asyncなど、一部のマクロは入力をクロージャでラップします。そのようなコード内で@__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()
:bar
Julia 1.13

このマクロを使うには、Julia 1.13以降が必要です。

source
Base.@__FILE__ — Macro
@__FILE__ -> String

マクロ呼び出しを含むファイルへのパスを文字列として展開します。julia -e <expr>によって評価された場合は、空文字列を返します。マクロにパーサーのソース情報がなかった場合は、nothingを返します。あるいは、PROGRAM_FILEを参照してください。

source
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/JuliaUser
source
Base.@__LINE__ — Macro
@__LINE__ -> Int

マクロ呼び出しがある位置の行番号に展開します。行番号を特定できない場合は、0を返します。

source
Base.fullname — Function
fullname(m::Module)

モジュールの完全修飾名をシンボルのタプルとして取得します。たとえば、

Examples

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

julia> fullname(Main)
(:Main,)
source
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() を渡します。

Note

sym ∈ names(SomeModule) は isdefined(SomeModule, sym) を意味するものではありません。names は、モジュール内で定義されていなくても、public または export としてマークされたシンボルを返すことがあります。

Warning

names は、重複した名前を返すことがあります。たとえば、import された名前が既存の識別子と競合すると、重複が発生します。

Julia 1.12

usings 引数を使用するには、Julia 1.12 以降が必要です。

関連項目: Base.isexported、Base.ispublic、Base.@locals、@__MODULE__。

source
Base.isexported — Function
isexported(m::Module, s::Symbol)::Bool

シンボルがモジュールからエクスポートされているかどうかを返します。

関連項目: ispublic、names

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)
false
source
Base.ispublic — Function
ispublic(m::Module, s::Symbol)::Bool

シンボルがモジュール内で public としてマークされているかどうかを返します。

エクスポートされたシンボルは public とみなされます。

Julia 1.11

この関数と public という概念は、Julia 1.11 で追加されました。

関連項目: 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)
false
source
Base.nameof — Method
nameof(f::Function)::Symbol

ジェネリックなFunctionの名前をシンボルとして取得します。無名関数の場合、これはコンパイラーが生成した名前です。Functionの明示的に宣言されたサブタイプの場合、これは関数の型の名前です。

source
Base.functionloc — Method
functionloc(f::Function, types)

ジェネリックな Function の定義位置を示すタプル (filename,line) を返します。

source
Base.functionloc — Method
functionloc(m::Method)

(filename,line) を返します。これは Method 定義の位置を示すタプルです。

source
Base.@locals — Macro
@locals()

呼び出し位置で定義されているすべてのローカル変数について、名前(シンボル)と値を対応付けた辞書を構築します。

Julia 1.1

このマクロを使用するには、Julia 1.1 以降が必要です。

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)
source
Core.getglobal — Function
getglobal(module::Module, name::Symbol, [order::Symbol=:monotonic])

モジュール module から、束縛 name の値を取得します。この操作にはアトミック順序を任意で指定できます。指定しない場合、デフォルトは monotonic です。

互換性を維持するため、getfield によるモジュールの束縛へのアクセスも引き続きサポートされていますが、常に getglobal を優先して使用すべきです。getglobal ではアトミック順序を制御でき(getfield は常に monotonic)、ユーザーにもコンパイラにもコードの意図がより明確に伝わるためです。

ほとんどのユーザーは、この関数を直接呼び出す必要はありません。ごく少数の非常に限定的なユースケースを除き、getproperty 関数または対応する構文(module.name)を優先して使用すべきです。

Julia 1.9

この関数には Julia 1.9 以降が必要です。

getproperty および setglobal! も参照してください。

Examples

julia> a = 1
1

julia> module M
       a = 2
       end;

julia> getglobal(@__MODULE__, :a)
1

julia> getglobal(M, :a)
2
source
Core.setglobal! — Function
setglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])

モジュール module 内の束縛 name の値を x に設定または変更します。型変換は行われないため、束縛にすでに型が宣言されている場合、x は適切な型でなければならず、そうでない場合はエラーが発生します。

この操作では、アトミック順序を指定することもできます。指定しない場合は、デフォルトで monotonic になります。

通常、ユーザーは setproperty! 関数または対応する構文(つまり module.name = x)を通じてこの機能を利用するため、これは非常に限定的な用途を想定しています。

Julia 1.9

この関数を使用するには、Julia 1.9 以降が必要です。

関連項目: 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
1
source
Core.modifyglobal! — Function
modifyglobal!(module::Module, name::Symbol, op, x, [order::Symbol=:monotonic])::Pair

関数 op を適用した後、グローバル変数の取得と設定をアトミックに実行します。

Julia 1.11

この関数を使用するには、Julia 1.11 以降が必要です。

modifyproperty! および setglobal! も参照してください。

source
Core.swapglobal! — Function
swapglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])

グローバル変数の取得と設定を同時に、アトミックに実行します。

Julia 1.11

この関数を使用するには、Julia 1.11 以降が必要です。

関連項目: swapproperty!、setglobal!。

source
Core.setglobalonce! — Function
setglobalonce!(module::Module, name::Symbol, value,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

グローバル変数がまだ設定されていない場合に限り、指定した値を設定する操作をアトミックに実行します。

Julia 1.11

この関数を使用するには、Julia 1.11 以降が必要です。

関連項目: setpropertyonce!、setglobal!。

source
Core.replaceglobal! — Function
replaceglobal!(module::Module, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

グローバル変数の値を取得し、条件を満たす場合に指定した値へ設定する操作をアトミックに実行します。

Julia 1.11

この関数を使用するには、Julia 1.11 以降が必要です。

関連項目: replaceproperty!、setglobal!。

source
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
Julia 1.12

この関数を使用するには Julia 1.12 以降が必要です。それ以前のバージョンの Julia で定数を再定義した場合の動作は予測できません。

関連項目: const。

source

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""
Julia 1.11

Julia 1.11 以降では、@doc マクロでドキュメントを取得するには、REPL 標準ライブラリを読み込む必要があります。

Functions & Methods

メソッド定義(例: function foo() ... や foo() = ...)の前にドキュメントを置くと、関数全体ではなく、その特定のメソッドがドキュメント化されます。関数のドキュメントを構成するため、各メソッドのドキュメントは定義された順に連結されます。

source
Base.Docs.HTML — Type

HTML(s): s を HTML としてレンダリングするオブジェクトを作成します。

HTML("<div>foo</div>")

大量のデータを扱う場合は、ストリームも使用できます。

HTML() do io
  println(io, "<div>foo</div>")
end
Warning

HTML は後方互換性を維持するため現在もエクスポートされていますが、このエクスポートは非推奨です。この型は Docs.HTML として使用するか、Docs から明示的にインポートすることを推奨します。

source
Base.Docs.Text — Type

Text(s): sをプレーンテキストとして出力するオブジェクトを作成します。

Text("foo")

大量のデータを扱う場合は、ストリームも使用できます。

Text() do io
  println(io, "foo")
end
Warning

Textは後方互換性を維持するため現在もエクスポートされていますが、このエクスポートは非推奨です。この型はDocs.Textとして使用するか、Docsから明示的にインポートすることを推奨します。

source
Base.Docs.hasdoc — Function
Docs.hasdoc(mod::Module, sym::Symbol)::Bool

true を返します。ただし、mod 内の sym に docstring がある場合は false を返します。

source
Base.Docs.undocumented_names — Function
undocumented_names(mod::Module; private=false)

module 内のドキュメント化されていないシンボル(docstring がないシンボル)を、ソート済みのベクトルとして返します。private=false(デフォルト)は、public および/または export で宣言された識別子のみを返します。一方、private=true は、モジュール内のすべてのシンボルを返します(# で始まる、コンパイラが生成した非表示シンボルは除きます)。

関連項目:names、Docs.hasdoc、Base.ispublic。

source

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 LinearAlgebra
source
Base.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"
source
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 の各セクションを参照してください。

source
Base.compilecache — Function
Base.compilecache(module::PkgId)

モジュールとそのすべての依存関係を含む、プリコンパイル済みキャッシュファイルを作成します。これにより、パッケージの読み込み時間を短縮できます。キャッシュファイルはDEPOT_PATH[1]/compiledに保存されます。重要な注意事項については、Module initialization and precompilationを参照してください。

source
Base.isprecompiled — Function
Base.isprecompiled(pkg::PkgId; ignore_loaded::Bool=false)

指定した PkgId がアクティブなプロジェクト内でプリコンパイル済みかどうかを返します。

デフォルトでは、依存関係の異なるバージョンが現在読み込まれている場合の扱いについて、コードの読み込み時と同じ方法で判定します。読み込み済みのモジュールを無視し、新しい Julia セッションであるかのように判定するには、ignore_loaded=true を指定します。

Julia 1.10

この関数を使用するには、Julia 1.10 以降が必要です。

source
Base.get_extension — Function
get_extension(parent::Module, extension::Symbol)

parent の extension モジュールを返します。拡張機能が読み込まれていない場合は、nothing を返します。

source

Internals

Base.GC.gc — Function
GC.gc([full=true])

ガベージコレクションを実行します。引数 full は、コレクションの種類を指定します。デフォルトのフルコレクションでは、すべての生存オブジェクトを走査(つまり、完全なマーク処理)し、到達不能なオブジェクトのメモリをすべて回収します。インクリメンタルコレクションでは、到達不能な若いオブジェクトのメモリのみを回収します。

インクリメンタルコレクションを要求した場合でも、GC がフルコレクションを実行することがあります。

Warning

過度に使用すると、パフォーマンスが低下する可能性があります。

source
Base.GC.enable — Function
GC.enable(on::Bool)

ブール値の引数でガベージコレクションを有効にするかどうかを指定します(有効にする場合はtrue、無効にする場合はfalse)。以前のGCの状態を返します。

Warning

ガベージコレクションを無効にすると、メモリ使用量が際限なく増加する可能性があるため、慎重に使用してください。

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

ccall にポインターを渡す場合、ポインターが指すオブジェクトは暗黙的に使用されるため、保持しておく必要があります。ただし通常は、x を ccall に直接渡すだけでかまいません。これは明示的な使用として扱われます。

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

ガベージコレクションが実行される可能性のあるポイントをプログラム内に挿入します。

セーフポイントは高速で、それ自体がガベージコレクションを開始することはありません。ただし、別のスレッドがGCの実行を要求している場合、セーフポイントに到達すると、現在のスレッドはブロックしてGCの完了を待ちます。

これは、マルチスレッドプログラムでまれに役立つことがあります。あるタスクがメモリを割り当てている(そのためGCの実行が必要になる可能性がある)一方で、別のタスクは単純な操作だけを行っている(メモリ割り当て、タスク切り替え、I/Oを行わない)場合です。後者のタスクはJuliaのランタイムに制御を渡さないため、GCの実行を妨げます。メモリを割り当てないタスクでこの関数を定期的に呼び出すと、ガベージコレクションを実行できるようになります。

セーフポイントは高速(通常は約2クロックサイクル)ですが、タイトなループ内で呼び出すとパフォーマンスが低下することがあります。

Julia 1.4

この関数はJulia 1.4以降で利用できます。

source
Base.GC.enable_logging — Function
GC.enable_logging(on::Bool)

有効にすると、各 GC に関する統計情報を stderr に出力します。

source
Base.Meta.lower — Function
lower(m, x)

式 x を受け取り、モジュール m で実行するための、低レベル形式の等価な式を返します。code_lowered も参照してください。

source
Base.Meta.@lower — Macro
@lower [m] x

式 x をモジュール m で展開した形で返します。デフォルトでは、マクロが呼び出されたモジュールが m になります。lower も参照してください。

source
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)
source
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")))
source
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)
Julia 1.13

legacyscope キーワード引数を使用するには、Julia 1.13 以降が必要です。

source
Base.macroexpand! — Function
macroexpand!(m::Module, x; recursive=true, legacyscope=false)

式 x を受け取り、すべてのマクロを展開した同等の式を返します。モジュール m で実行するために、コピーを作成せず x をその場で変更します。recursive キーワードは、ネストしたマクロのより深い階層も展開するかどうかを制御します。legacyscope キーワードは、従来のマクロスコープ展開を行うかどうかを制御します。

この関数は最初のコピー処理を行わずにマクロを展開するため、元の式が不要な場合はより効率的です。必要に応じてマクロスコープ展開を別途実行できるため、その場で展開する場合はデフォルトで無効になっています。

Warning

この関数は入力式 x をその場で変更します。元の式を保持する必要がある場合は、macroexpand を使用してください。

Julia 1.13

この関数を使用するには、Julia 1.13 以降が必要です。

source
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 では、最初の引数で指定したモジュール内で式が展開されます。

Julia 1.11

2引数形式を使用するには、Julia 1.11以降が必要です。

source
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 が具象型でなければエラーがスローされることに注意してください。

source
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
) => Int64
source
Base.precompile — Function
precompile(f, argtypes::Tuple{Vararg{Any}}, m::Method)

指定した引数型に対する特定のメソッドを事前コンパイルします。これにより、通常のディスパッチで選択されるメソッドとは異なるメソッドを事前コンパイルでき、invoke を模倣できます。

source
precompile(f, argtypes::Tuple{Vararg{Any}})

指定された関数 f を、引数タプル(型)argtypes に対してコンパイルします。ただし、実行はしません。

source
Base.jit_total_bytes — Function
Base.jit_total_bytes()

たとえば、ネイティブコードやデータのためにジャストインタイムコンパイラが割り当てた総量(バイト単位)を返します。

source

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)
source
Base.isexpr — Function
Meta.isexpr(ex, head[, n])::Bool

exが指定された型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)
true
source
Base.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)
source
Base.Meta.isoperator — Function
isoperator(s::Symbol)

その記号を演算子として使用できる場合は、trueを返し、使用できない場合はfalseを返してください。

Examples

julia> Meta.isoperator(:+), Meta.isoperator(:f)
(true, false)
source
Base.Meta.isunaryoperator — Function
isunaryoperator(s::Symbol)

その記号を単項(前置)演算子として使用できる場合は、trueを返します。使用できない場合は、falseを返します。

Examples

julia> Meta.isunaryoperator(:-), Meta.isunaryoperator(:√), Meta.isunaryoperator(:f)
(true, true, false)
source
Base.Meta.isbinaryoperator — Function
isbinaryoperator(s::Symbol)

その記号を二項(中置)演算子として使用できる場合は、trueを返します。そうでない場合は、falseを返します。

Examples

julia> Meta.isbinaryoperator(:-), Meta.isbinaryoperator(:√), Meta.isbinaryoperator(:f)
(true, false, false)
source
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))
source