基本的な関数

はじめに

Julia Base ライブラリには科学計算や数値計算で使われる様々な関数やマクロの中で、他の汎用プログラミング言語でも見られる一般的なものが含まれています。これ以外の機能は日々追加される種々のパッケージから利用できます。このドキュメントでは Julia Base に含まれる関数をトピックごとに分けて示します。

一般的な注意事項を示します:

言語で基礎的な役割を持つ関数

Base.exit ── 関数

exit(code=0)

プログラムを与えられた終了コードで終了します。デフォルトの終了コードは 0 であり、これはプログラムが正常に終了したことを示します。対話セッションではキーボードショートカット ^Dexit() を呼び出せます。

Base.atexit ── 関数

atexit(f)

ゼロ引数の関数 f() をプロセスが終了するときに呼ばれる関数として登録します。atexit() で設定した終了フックは後入れ先出し (last in first out, LIFO) の順序でオブジェクトのファイナライザの前に呼び出されます。

終了フックは exit(n) を呼び出すことを許されており、こうすると Julia の終了コードが n になります (元々の終了コードは無視されます)。複数の終了フックが exit(n) を呼んだ場合には、Julia は最後に呼び出された exit(n) に渡された値を最終的な終了コードとします (終了フックは LIFO の順序で呼ばれるので、「最後に呼び出された」は「最初に登録された」と等価です)。

Base.isinteractive ── 関数

isinteractive() -> Bool

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

Base.summarysize ── 関数

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

引数に渡されたオブジェクトから到達可能なユニークなオブジェクトが使用しているメモリの総量を計算して返します (単位はバイト)。

キーワード引数

  • exclude: 走査から除外するオブジェクトの型を指定します。
  • chargeall: 必ず全てのフィールドをサイズに数えるオブジェクトの型を指定します。通常は除外される型を持つフィールドであっても、chargeall に指定した型のフィールドはサイズとしてカウントされます。

Base.require ── 関数

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

これは usingimport の実装で使われる関数であり、モジュールがこれまでに Main で定義されていないときに呼ばれます。これまでに読み込んだかどうかに関係なくモジュールの再読み込みを強制的に行うために require を直接呼び出すこともできます (ライブラリを対話的に開発しているときなど)。

全てのアクティブなノード上で、Main モジュールのコンテキストでソースファイルを読み込みます。ファイルは標準的な場所から検索されます。require はトップレベルの操作とみなされるので、ファイルを読み込んでいる間だけ有効なパスを設定しますが、そのパスはファイルの検索に利用されません (参照: include)。この関数は通常ライブラリコードを読み込むのに使われ、パッケージを読み込むときにもusing から間接的に呼ばれます。

ファイルを検索するとき、require は最初グローバル配列 LOAD_PATH に含まれるパッケージコードを検索します。require は全てのプラットフォームで大文字と小文字を区別して検索を行います。この振る舞いは macOS や Windows のような大文字と小文字を区別しないファイルシステムを持つプラットフォームでも同様です。

コードの読み込みに関して詳しくは、マニュアルのモジュール並列計算の章を参照してください。

Base.compilecache ── 関数

Base.compilecache(module::PkgId)

モジュール module とその依存モジュールに対して事前コンパイルを行い、キャッシュファイルを作成します。この関数はパッケージの読み込み時間を短縮するために利用できます。作成されるキャッシュファイルは DEPOT_PATH[1]/compiled に保存されます。モジュールの初期化と事前コンパイルの節に詳しい情報があります。

Base.__precompile__ ── 関数

__precompile__(isprecompilable::Bool)

この関数を呼び出したファイルが事前コンパイルできるかどうかを指定します。デフォルトは true です。モジュールあるいはファイルを安全に事前コンパイルできないなら、そのモジュールあるいはファイルから __precompile__(false) を呼び出して Julia が事前コンパイルしようとしたときにエラーが発生するようにするべきです。

Base.include ── 関数

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

モジュール m のグローバルスコープで入力されたソースファイルの内容を評価します。baremodule で定義されたモジュールを除く全てのモジュールには m 引数を省略した include 関数が定義され、この include 関数は自身が含まれるモジュールでファイルを評価します。入力ファイルで最後に評価した式の評価結果を返します。インクルード処理の間、インクルードされるファイルを含むディレクトリがタスクにローカルなインクルードパスに設定されます。そのため include をネストして呼び出すと、最初に読み込んだファイルを含むディレクトリからの相対パスも検索されます。通常この関数が使われるのはソースを対話的に読み込むとき、および複数のソースファイルに分割されたパッケージを一つに組み合わせるときです。

省略可能な第一引数 mapexpr を使うとインクルードされるコードを評価する前に変形できます。path 内のパースされた全ての式 expr について、includemapexpr(expr) を評価します。mapexpr が省略されたときのデフォルト値は identity です。

Base.MainInclude.include ── 関数

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

この関数を持つモジュールのグローバルスコープでファイル path の内容を評価します。(baremodule で定義されたモジュールを除く) 全てのモジュールそれぞれに include 関数が定義され、その include 関数はそのモジュールでファイルを評価します。入力ファイルで最後に評価した式の評価結果を返します。インクルード処理の間、インクルードされるファイルを含むディレクトリがタスクにローカルなインクルードパスに設定されます。そのため include をネストして呼び出すと、最初に読み込んだファイルを含むディレクトリからの相対パスも検索されます。通常この関数が使われるのはソースを対話的に読み込むとき、および複数のソースファイルに分割されたパッケージを一つに組み合わせるときです。

省略可能な第一引数 mapexpr を使うとインクルードされるコードを評価する前に変形できます。path 内のパースされた全ての式 expr について、includemapexpr(expr) を評価します。mapexpr が省略されたときのデフォルト値は identity です。

他のモジュールでファイルを評価するには Base.include を使ってください。

Base.include_string ── 関数

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

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

省略可能な第一引数 mapexpr を使うとインクルードされるコードを評価する前に変形できます。path 内のパースされた全ての式 expr について、include_stringmapexpr(expr) を評価します。mapexpr が省略されたときのデフォルト値は identity です。

Base.include_dependency ── 関数

include_dependency(path::AbstractString)

モジュール内部で利用できます。相対または絶対のパス path で指定されるファイルが事前コンパイル時の依存ファイルであると宣言します。つまり、path にあるファイルが変更されたらこのモジュールも再コンパイルが必要であることを宣言します。

この関数が必要なのは、あなたのモジュールが直接 include しないファイルに依存するときだけです。この関数はコンパイル処理以外に影響しません。

Base.which ── メソッド

which(f, types)

types 型の引数を与えたときに呼ばれる f のメソッドを返します。

types が抽象型なら、invoke が呼び出すメソッドを返します。

Base.methods ── 関数

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

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

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

Julia 1.4

methods でモジュールを指定するには最低でも Julia 1.4 が必要です。

[email protected] ── マクロ

@show

式とその評価結果を表示し、評価結果を返します。show も参照してください。

ans ── キーワード

ans

最後に計算した値を指す変数です。対話プロンプトで自動的に設定されます。

キーワード

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 です。これらのキーワードは変数の名前として許されていません。

abstract type, mutable struct, primitive type という二語の並びも予約されています。ただし abstract, mutable, primitive, type という名前の変数を作ることはできます。

最後に、where はパラメータを持つメソッドおよび型の定義で使われる中置演算子としてパースされ、inisa も中置演算子としてパースされます。ただし where, in, isa という名前の変数を作ることはできます。

module ── キーワード

module

moduleモジュールを宣言します。モジュールは独立したグローバル変数のワークスペースです。モジュール内部では他のモジュールが持つ名前のどれが見えるかを (インポートで) 制御でき、また自身のモジュールに含まれる名前の中でパブリックにするのはどれかを (エクスポートで) 指定できます。モジュールを使えば、他のコードと一緒に使われたときの名前の衝突を気にすることなくトップレベルの定義を作成できます。詳細はマニュアルのモジュールの章を参照してください。

module Foo
import Base.show
export MyType, foo

struct MyType
    x
end

bar(x) = 2x
foo(a::MyType) = bar(a.x) + 1
show(io::IO, a::MyType) = print(io, "MyType $(a.x)")
end

export ── キーワード

export

export はモジュールに含まれる識別子の中でユーザーから利用可能なものを Julia に伝えるために使われます。例えば export foo とすると、そのモジュールを using したときに名前 foo が利用可能になります。詳細はマニュアルのモジュールの章を参照してください。

import ── キーワード

import

import Foo はモジュールまたはパッケージ Foo を読み込みます。インポートした Foo モジュールの名前にはドット構文でアクセスできます (例えば foo という名前にアクセスするには Foo.foo とします)。詳細はマニュアルのモジュールの章を参照してください。

using ── キーワード

using

using Foo はモジュールまたはパッケージ Foo を読み込み、そのパッケージが export する名前を直接使えるようにします。名前にはドット構文を使っても (例えば名前 foo には Foo.foo で) アクセスでき、そのときは名前が export されたかどうかに関係なくアクセスが可能です。詳細はマニュアルのモジュールの章を参照してください。

baremodule ── キーワード

baremodule

baremoduleusing Base という文と eval の定義を持たないモジュールを宣言します。ただし baremodule で宣言するモジュールでも Core は依然インポートされます。

function ── キーワード

function

function キーワードは関数を定義します:

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

関数は代入形式を使っても定義できます:

add(a, b) = a + b

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

macro ── キーワード

macro

macro は生成されたコードをプログラムに挿入する手続きを定義します。マクロは引数に式の列を受け取って一つの式を返し、返り値の式はプログラムのマクロを呼び出した場所に直接挿入されます。マクロによって生成されたコードは周りのプログラムの一部となるので、マクロは eval を使わずにコードを生成して実行するための仕組みと言えます。マクロの引数として許されているのは式・リテラル値・シンボルです。可変長引数を持つマクロは定義できますが、マクロでキーワード引数は使えません。

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

julia> @sayhello "Charlie"
Hello, Charlie!

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

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

return ── キーワード

return

関数で 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

としたとき、一つ目の例では x が最初に偶数となったときに returntest1 関数を終了させるので、test1([5,6,7])12 を返します。

二つ目の例でも同じだろうと思うかもしれませんが、test2 に含まれる return内側の関数 (do ブロックの内側の関数) を終了させ、return に渡される値 2xmap の返り値の一部となります。そのため test2([5,6,7])[5,12,7] を返します。

トップレベル (つまり関数の外) で return を使うと、現在のトップレベル式がその時点で終了します。

do ── キーワード

do

無名関数を作成し、それを前にある関数呼び出しの第一引数として渡します。例えば次の構文は map(x->2x, 1:10) と等価です:

map(1:10) do x
    2x
end

複数の引数を使うには次のようにします:

map(1:10, 11:20) do x, y
    x + y
end

begin ── キーワード

begin

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

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

functionlet といったキーワードが暗黙にブロックを始めるので、通常 begin は必要になりません。; も参照してください。

end ── キーワード

end

end は式のブロックの終わりを示します。例えば module, struct, mutable struct, begin, let, for で始まるブロックは end で終わらせます。配列に対する添え字アクセスで添え字として end を使うと、次元における最後の添え字となります。

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

julia> A[end, :]
2-element Array{Int64,1}:
 3
 4

let ── キーワード

let

let 文は実行するたびに新しい変数束縛をアロケートします。代入文は値の保管場所が既に作成されていればそれを再利用しますが、let は必ず新しい保管場所を作成するということです。この違いによって動作が変わるのは、クロージャを通して変数がスコープが終わった後も生き残る場合だけです。let の構文はコンマで区切られた代入文と変数の名前の列を受け取ります:

let var1 = value1, var2, var3 = value3
    code
end

代入文は順番に評価され、右辺は左辺の変数が作成される前のスコープで評価されます。そのため let x = x としても問題はありません。x で表される二つの変数は異なる変数であり、個別の格納場所を持つためです。

if ── キーワード

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 < ytrue だと、その直後にある対応するブロックが評価されます。そうでなければ次の条件式 x > y が評価され、それが true なら、その直後のブロックが評価されます。二つの条件文がどちらも false なら、else ブロックが評価されます。elseifelse は省略可能であり、elseif は好きな数だけ付けられます。

for ── キーワード

for

for は値の並びから値を一つずつ取りながら反復的に文のブロックを評価します。

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

while ── キーワード

while

while は「条件式を評価し、その評価結果が true なら本体を評価する」という処理を繰り返し行います。処理が初めて while ループに到達したときに条件式が false だと、ループの本体は一度も評価されません。

julia> i = 1
1

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

break ── キーワード

break

すぐにループから脱出します。

julia> i = 0
0

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

continue ── キーワード

continue

現在実行中のループの残りの部分を飛ばして、次の反復に進みます。

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

try ── キーワード

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 ブロックで有効な変数 e に束縛できます。

try/catch 構文の強みは、深くネストされた処理から呼び出しスタックのずっと高い位置まで一気に戻れることです。

finally ── キーワード

finally

与えられたブロックの実行が終わったときに、どう終わったかに関係なく実行するブロックを指定します。例えば、次のコードでは開かれたファイルが閉じられることが保証されています:

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

制御が try ブロックから離れるとき (例えば return を呼んだとき、あるいは通常通り実行を終えたとき)、close(f) が必ず実行されます。try ブロックの実行が例外によって終了したときは、finally ブロックが実行されてから例外が上へ伝播されます。catch ブロックを try/finally と組み合わせることもでき、その場合 finally ブロックは catch がエラーを処理した後に呼ばれます。

quote ── キーワード

quote

quote はブロックに含まれる複数の式を表すオブジェクトを Expr を使うことなく作成します。例を示します:

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

クオートを行うもう一つの記法 :(...) とは異なり、この記法を使うと式を表す木に QuoteNode 要素が現れることがあります。そのため、この記法で作成した木を直接操作するときは注意が必要です。それ以外の用途では、:(...)quote ... end ブロックは同じように扱えます。

local ── キーワード

local

local は新しいローカル変数を作成します。詳細はマニュアルの変数のスコープに関する章を参照してください。

julia> function foo(n)
           x = 0
           for i = 1:n
               local x # ループにローカルな x を作成する。
               x = i
           end
           x
       end
foo (generic function with 1 method)

julia> foo(10)
0

global ── キーワード

global

global x とすると、現在のスコープおよびそれより内側のスコープで x という変数が同名のグローバル変数を指すようになります。詳細はマニュアルの変数のスコープに関する章を参照してください。

julia> z = 3
3

julia> function foo()
           global z = 6 # foo の外側で定義された変数 z を使う。
       end
foo (generic function with 1 method)

julia> foo()
6

julia> z
6

const ── キーワード

const

const は値が変更されないグローバル変数を宣言するときに使います。ほぼ全てのコードにおいて (特に性能が重要なコードでは)、グローバル変数は const を使って定数と宣言されるべきです。

const x = 5

一つの const で複数の変数を定数として宣言できます:

const y, z = 7, 11

const は一つの = 演算だけに適用されるので、const x = y = 1 としても定数になるのは x だけで y は定数にならないことに注意してください。これに対して const x = const y = 1 とすれば xy の両方が定数となります。

また可変コンテナは “定数” にならないことにも注意が必要です。定数になるのは、変数と値の間の結びつきだけです。例えば xconst x と定義された配列や辞書であったとしても、それに対する要素の変更/追加/削除は可能です。

一部の状況では const 変数の値を変えたときにエラーではなく警告が発生することがあります。しかし、その後に予期できない振る舞いやプログラムの状態の破壊が引き起こされる可能性があるので、定数の値の変更は行わないでください。この機能は対話的な利用を便利にするために追加されたものです。

struct ── キーワード

struct

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

struct Point
    x
    y
end

フィールドには型の制約を付けることができ、パラメータ化も可能です:

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

<: を使うと、抽象型を構造体の上位型として宣言できます:

struct Point <: AbstractPoint
    x
    y
end

struct はデフォルトで不変 (immutable) です: struct で作成した型のインスタンスは、一度構築すると変更できません。インスタンスを変更できる型を宣言するには mutable struct を使ってください。

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

mutable struct ── キーワード

mutable struct

mutable structstruct と似ていますが、mutable struct で宣言される型のフィールドは構築後に変更できます。詳細はマニュアルの複合型の節を参照してください。

abstract type ── キーワード

abstract type

abstract type はインスタンス化できない型 (抽象型) を宣言します。abstract type で宣言される抽象型は型グラフにおける頂点としてのみ利用でき、関連する具象型 (型グラフで子となる型) の集合を表します。抽象型は Julia の型システムをオブジェクトの実装の寄せ集め以上のものにする理論的な型階層を形成します。例えば次のように使われます:

abstract type Number end
abstract type Real <: Number end

Number は上位型を持たない抽象型で、RealNumber の部分型である抽象型であることをこのコードは表しています。

primitive type ── キーワード

primitive type

primitive type はデータがビット列だけで構成される具象型 (プリミティブ型) を宣言します。プリミティブ型の典型例は整数型と浮動小数点数型です。組み込みのプリミティブ型宣言の例を示します:

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

名前の後の数値は、その型の保存に必要なビット数を表します。現在の Julia は 8 の倍数のサイズだけをサポートします。上記の Bool の宣言のように、何らかの上位型の部分型としてプリミティブ型を宣言することもできます。

where ── キーワード

where

where を使うと、「ある変数が取り得る値のそれぞれで宣言される型を全て合併した型」を定義できます。例えば Vector{T} where T<:Real には要素型が何らかの Real である Vector が全て含まれます。

変数の上界を省略すると Any がデフォルト値として使われます:

Vector{T} where T    # "Vector{T} where T<:Any" の短縮形

変数には下界も付けられます:

Vector{T} where T>:Int
Vector{T} where Int<:T<:Real

where 式をネストするための構文もあります。例えば

Pair{T, S} where S<:Array{T} where T<:Number

は、次のように短く書けます:

Pair{T, S} where {T<:Number, S<:Array{T}}

この形式はメソッドのシグネチャでよく使われます。

この形式を使うときは、元々の書き方で一番外側にあった変数を最初に書くことに注意してください。これは T{p1, p2, ...} によってパラメータに型が “適用” されるときに置換が起こる順番と同じです。

... ── キーワード

...

“splat” 演算子 ... は引数の列 (可変長引数) を表します。... を関数の定義で使うと関数が可変長引数を受け取ることを宣言できます。また ... は引数の列を関数に渡すときにも使います。

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

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

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

julia> add(7, 1:100..., 1000:1100...)
111107

; ── キーワード

;

Julia の ; は C に似た言語と同様の意味を持ち、それまでの文を区切るために使われます。改行があれば ; は必要ありませんが、同じ行に書かれる複数の文を区切るときや複数の文を一つの式にまとめるときに ; は利用できます。REPL などのインターフェースで評価結果の出力を抑制するときにも ; は使われます。

julia> function foo()
           x = "Hello, "; x *= "World!"
           return x
       end
foo (generic function with 1 method)

julia> bar() = (x = "Hello, Mars!"; return x)
bar (generic function with 1 method)

julia> foo();

julia> bar()
"Hello, Mars!"

= ── キーワード

=

代入演算子です。

  • 変数 a と式 b に対して、a = ba の参照先を b の値とします。
  • f(x) = X は関数 f が定義されていなければ新しい関数定数 f を定義し、f が定義されていればそれに新しいメソッドを追加します。f(x) = Xfunction f(x); X; end と等価です。
  • a[i] = vsetindex!(a,v,i)を呼び出します。
  • a.b = csetproperty!(a,:b,c) を呼び出します。
  • 関数の呼び出しで f(a=b) とすると、b がキーワード引数 a の値となります。
  • コンマを持つ括弧の内部で (a=1,) とすると、NamedTuple が構築されます。

ab に代入しても b のコピーは作成されません。コピーの作成には copy または deepcopy を使ってください。

julia> b = [1]; a = b; b[1] = 2; a
1-element Array{Int64,1}:
 2

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

関数に渡されるコレクションもコピーされません。関数は引数が指すオブジェクトの内容を変更 (改変) できます (引数を変更する関数は名前の最後を ! とするのが慣習となっています):

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

julia> a = [1]; f!(a); a
1-element Array{Int64,1}:
 2

複数の変数に対する並列代入が可能です。そのとき左辺は反復可能オブジェクトとします:

julia> a, b = 4, 5
(4, 5)

julia> a, b = 1:3
1:3

julia> a, b
(1, 2)

複数の変数に対する直列的な代入も可能です。返り値は一番右にある式の値となります:

julia> a = [1]; b = [2]; c = [3]; a = b = c
1-element Array{Int64,1}:
 3

julia> b[1] = 2; a, b, c
([2], [2], [2])

コレクションに対して範囲外の代入を行っても、コレクションが自動的に大きくなることはありません。コレクションが Vector なら、push!append! を使って大きくできます:

julia> a = [1, 1]; a[3] = 2
ERROR: BoundsError: attempt to access 2-element Array{Int64,1} at index [3]
[...]

julia> push!(a, 2, 3)
4-element Array{Int64,1}:
 1
 1
 2
 3

コレクションに [] を代入しても、その要素はコレクションから削除されません。要素の削除には filter! を使ってください。

julia> a = collect(1:3); a[a .<= 1] = []
ERROR: DimensionMismatch("tried to assign 0 elements to 1 destinations")
[...]

julia> filter!(x -> x > 1, a) # インプレースなので a = a[a .> 1] より高速
2-element Array{Int64,1}:
 2
 3

?: ── キーワード

a ? b : c

条件文の短縮形です。「a なら b を実行せよ、それ以外のときは c を実行せよ」を意味します。これは三項演算子とも呼ばれます。

この構文は if a; b else c end と等価ですが、大きな式の一部で b または c の (副作用ではなく) 値を強調するためによく使われます。

詳細はマニュアルの制御構造の章を参照してください。

julia> x = 1; y = 2;

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

標準モジュール

Main ── モジュール

Main

Main はトップレベルモジュールであり、Julia は Main を現在のモジュールとして実行を始めます。プロンプトで定義された変数は Main に格納され、varinfo()Main で定義された変数を一覧で表示します:

julia> @__MODULE__
Main

julia> varinfo()
  name                    size summary
  –––––––––––––––– ––––––––––– –––––––
  Base                         Module
  Core                         Module
  InteractiveUtils 198.387 KiB Module
  Main                         Module

Core ── モジュール

Core

Core は言語に「組み込み (built-in)」とみなされる識別子を全て含むモジュールです。つまり Core に含まれる識別子はコア言語の一部であり、ライブラリの一部ではありません。こういった識別子の定義が存在しないと何もできないので、全てのモジュールは暗黙に using Core を実行するものとされます。

Base ── モジュール

Base

Julia の基礎ライブラリです。Base は基礎的な機能を持つモジュールであり、base/ 内のファイルからなります。Base モジュールはまず間違いなく必要になるので、全ての (baremodule でない) モジュールは暗黙に using Base を実行します。

Base のサブモジュール

Base.Broadcast ── モジュール

ブロードキャストの実装を提供します。

Base.Docs ── モジュール

@doc マクロなどを提供します。@doc マクロは Julia オブジェクトのドキュメントに関するメタデータの設定・取得を行います。

詳細はマニュアルのドキュメントの章を参照してください。

Base.Iterators ── モジュール

反復子を使うためのメソッドを提供します。

Base.Libc ── モジュール

C 標準ライブラリ libc に対するインターフェースを提供します。

Base.Meta ── モジュール

メタプログラミングで有用な関数を提供します。

Base.StackTraces ── モジュール

スタックトレースの収集・操作を行うツールを提供します。主にエラーの構築に使われます。

Base.Sys ── モジュール

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

Base.Threads ── モジュール

マルチスレッディングのサポートを提供します。

Base.GC ── モジュール

ガベージコレクションのユーティリティ関数を提供します。

全てのオブジェクトに関係する関数

Core.:=== ── 関数

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

xy が同じかどうかを判定します。ここで言う “同じ” とは、どんなプログラムを使っても区別できないという意味です。まず xy の型が比較されます。型が一致すると可変なオブジェクトはアドレスで比較され、不変なオブジェクト (数値など) はビット列として比較されます。この関数は「精密egalな比較」と呼ばれることもあります。返り値は必ず Bool 型の値です。

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

julia> a == b
true

julia> a === b
false

julia> a === a
true

Core.isa ── 関数

isa(x, type) -> Bool

x が与えられた型 type を持つかどうかを判定します。x isa type と中置演算子として使うこともできます。

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true

Base.isequal ── 関数

isequal(x, y)

基本的に == と同様ですが、浮動小数点数と欠損値の扱いが異なります。isequalNaNNaN を等しいとみなし、-0.00.0 を異なるとみなし、missingmissing を等しいとみなします。返り値は必ず Bool 型の値です。

実装

isequal のデフォルト実装は == を呼ぶので、浮動小数点数が絡まない型で定義する必要があるのは == だけです。

isequal はハッシュテーブル Dict が使う比較関数です。「isequal(x,y) ならば hash(x) == hash(y)」が成り立つ必要があります。

通常これは ==isequal のメソッドを独自に定義する型では対応する hash のメソッドも定義しなければならないこと (およびその逆) を意味します。多くのコレクション型は各要素に対して isequal を再帰的に呼び出すことで isequal を計算します。

スカラー型では基本的に == と異なる isequal を個別に定義する必要はありません。ただし、浮動小数点数を表現する型で isequal の汎用的なフォールバック (isnan, signbit, == を使うもの) よりも効率の良い実装が存在する型では定義するべきです。

julia> isequal([1., NaN], [1., NaN])
true

julia> [1., NaN] == [1., NaN]
false

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false
isequal(x)

受け取った引数が x と等しいかを isequal を使って比較する関数を返します。言い換えると、y -> isequal(y, x) と等価な関数を返します。

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

Base.isless ── 関数

isless(x, y)

xy より小さいかどうかを判定します。比較には固定された全順序が使われます。isless は全ての (x, y) の組に対して定義されているとは限りませんが、定義されるなら次の条件を満たすことが期待されます:

  • isless(x,y) が定義されているなら isless(y,x)isequal(x,y) も定義され、三つの中でちょうど一つが true を返す必要がある。
  • isless が定義する関係は推移律を満たす必要がある。つまり「isless(x,y) && isless(y,z) ならば isless(x,z)」が成り立たなければならない。

NaN のような通常は順序付いていない値には恣意的な順序が付いていますが、その順序は一貫しています。値 missing は順序で最後に位置づけられます。

islesssort が使うデフォルトの比較関数です。

実装

全順序を持つ数値でない型はこの関数を実装するべきです。数値型では NaN などの特殊な値を持つときにだけ実装が必要です。半順序を持つ型では < を実装してください。

julia> isless(1, 3)
true

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

Core.ifelse ── 関数

ifelse(condition::Bool, x, y)

conditiontrue なら x を返し、そうでなければ y を返します。これは関数なので、?if とは異なり全ての引数が最初に評価されます。if の代わりに ifelse を使うと生成されるコードから分岐が消えるので、性能が要求されるループで性能を改善できる場合があります。

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

Core.typeassert ── 関数

typeassert(x, type)

x isa type でなければ TypeError を発生させます。構文 x::type はこの関数を呼び出します。

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

Core.typeof ── 関数

typeof(x)

x の具象型を取得します。

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

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

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

Core.tuple ── 関数

tuple(xs...)

与えられたオブジェクトからなるタプルを構築します。

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

Base.ntuple ── 関数

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

長さ ni 番目の要素が f(i) であるタプルを作成します。

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

Base.objectid ── 関数

objectid(x)

オブジェクトのアイデンティティを使って計算される x のハッシュ値を取得します。「x === y ならば objectid(x) == objectid(y)」が成り立ちます。

Base.hash ── 関数

hash(x[, h::UInt])

オブジェクト x の整数のハッシュコードを計算します。「isequal(x,y) ならば hash(x)==hash(y)」が成り立ちます。省略可能な第二引数 h は計算結果と混ぜ合わせるハッシュコードを表します。

新しい型は二引数のメソッドを実装するべきです。典型的には二引数の hash メソッドを再帰的に呼び出し、オブジェクトが持つ要素それぞれのハッシュ (および h) を混ぜ合わせることでハッシュを計算する手続きが実装されます。基本的に、hash を実装する全ての型は == を独自に実装するべきです (このとき isequal も独自の実装となります)。また減算 (- 演算子) をサポートする型では、異種の要素を含む配列でハッシュを計算するために必要な widen も実装するべきです。

Base.finalizer ── 関数

finalizer(f, x)

x に対するプログラムからアクセス可能な参照が存在しなくなったときに呼ばれる関数として f(x) を登録します。x の型は mutable struct である必要があり、そうでなければこの関数は予期できない振る舞いをします。

f はタスクを切り替えてはいけません。このため println など大部分の IO 操作は行えません。デバッグでは @async マクロ (ファイナライザ外へのコンテキストスイッチを行わせる) や ccall を使って IO 関数を直接起動するとよいでしょう。

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

Base.finalize ── 関数

finalize(x)

オブジェクト x に登録されたファイナライザをすぐに実行します。

Base.copy ── 関数

copy(x)

x の浅いコピーを作成します: 外側の構造はコピーされますが、内側の値はコピーされません。例えば配列を浅くコピーすると、オリジナルと同一の要素を持った新しい配列が生成されます。

Base.deepcopy ── 関数

deepcopy(x)

x の深いコピーを作成します: 全ての要素が再帰的コピーされ、完全に独立したオブジェクトが作成されます。例えば配列を深くコピーすると、オリジナルの要素を深くコピーした値を要素に持つ新しい配列が作成されます。オブジェクトに対して deepcopy を呼ぶのは、一般に同じオブジェクトを一度シリアライズしてデシリアライズするのと同じ効果を持ちます。

通常は必要になりませんが、ユーザー定義型に対するデフォルトの deepcopy の振る舞いはオーバーライドできます。ユーザー型 Tdeepcopy をオーバーライドするには、deepcopy_internal(x::T, dict::IdDict) 関数を特殊化したメソッドを定義します。ここで dict は再帰呼び出しにおいてコピーされたオブジェクトを保持する辞書です。定義する deepcopy_internal の本体では、deepcopy を使う場所で deepcopy_internal を使い、返すときに dict 変数を適切に更新する必要があります。

Base.getproperty ── 関数

getproperty(value, name::Symbol)

構文 a.bgetproperty(a, :b) を呼び出します。

julia> struct MyType
           x
       end

julia> function Base.getproperty(obj::MyType, sym::Symbol)
           if sym === :special
               return obj.x + 1
           else # fallback to getfield
               return getfield(obj, sym)
           end
       end

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

propertynamessetproperty! も参照してください。

Base.setproperty! ── 関数

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

構文 a.b = csetproperty!(a, :b, c) を呼び出します。

propertynamesgetproperty も参照してください。

Base.propertynames ── 関数

propertynames(x, private=false)

オブジェクト x のプロパティ (x.property) からなるタプルまたはベクトルを返します。これは基本的に fieldnames(typeof(x)) と同じです。ただし getproperty をオーバーロードする型のインスタンスからプロパティを取得するには、一般に propertynames もオーバーロードする必要があります。

propertynames(x) が返せるのは、ドキュメントされた x のインターフェースに含まれる “パブリックな” プロパティだけです。内部での使用が意図される “プライベートな” フィールド名を取得したいなら、省略可能な第二引数を true としてください1x. に対する REPL のタブ補完は private=false で取得できるプロパティしか表示しません。

Base.hasproperty ── 関数

hasproperty(x, s::Symbol)

オブジェクト x がプロパティに s を持つかどうかを示す真偽値を返します。

Julia 1.2

この関数は Julia 1.2 以降でサポートされます。

Core.getfield ── 関数

getfield(value, name::Symbol)
getfield(value, i::Int)

複合型の値 value から名前または位置を使ってフィールドを取り出します。getpropertyfieldnames も参照してください。

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

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1

Core.setfield! ── 関数

setfield!(value, name::Symbol, x)

複合型の値 value のフィールド namex を代入します。value は可変である必要があり、xfieldtype(typeof(value), name) の部分型である必要があります。setproperty! も参照してください。

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

julia> setfield!(a, :field, 2);

julia> getfield(a, :field)
2

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

julia> setfield!(a, :num, 3);
ERROR: setfield! immutable struct of type Rational cannot be changed

Core.isdefined ── 関数

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

グローバル変数もしくはオブジェクトのフィールドが定義されているかどうかを判定します。引数は「モジュールとシンボル」または「複合型オブジェクトとフィールド名 (を表すシンボル)」または「複合型オブジェクトと位置」です。

配列の要素が定義されているかどうかを判定するには isassigned を使ってください。

@isdefined も参照してください。

julia> isdefined(Base, :sum)
true

julia> isdefined(Base, :NonExistentMethod)
false

julia> a = 1//2;

julia> isdefined(a, 2)
true

julia> isdefined(a, 3)
false

julia> isdefined(a, :num)
true

julia> isdefined(a, :numerator)
false

[email protected] ── マクロ

@isdefined s -> Bool

変数 s が現在のスコープで定義されているかどうかを判定します。

isdefined も参照してください。

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

julia> f()
false
true

Base.convert ── 関数

convert(T, x)

xT 型の値に変換します。

TInteger 型なら、xT で表現できないとき InexactError が発生します。例えば x が整数でない場合や、xT で表せる範囲を超えている場合です。

julia> convert(Int, 3.0)
3

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

TAbstractFloat 型もしくは Rational 型なら、T が表現できる値の中で最も x に近い値が返ります:

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(Rational{Int32}, x)
1//3

julia> convert(Rational{Int64}, x)
6004799503160661//18014398509481984

T がコレクション型で x がコレクションのときは、convert(T, x) の結果が x の一部または全部の別名となる可能性があります:

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

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

julia> y === x
true

Base.promote ── 関数

promote(xs...)

引数を共通の型に変換し、変換結果をタプルとして返します。引数を共通の型へ変換できないときはエラーが発生します。

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

Base.oftype ── 関数

oftype(x, y)

yx の型へ変換します。convert(typeof(x), y) と等価です。

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

Base.widen ── 関数

widen(x)

x が型なら、それを “広げた” 型を返します。つまり、x 型の値の任意の組に対する +- がオーバフローや精度落ちを起こさない型を返します。

128 ビットより小さい固定幅整数型に対しては、widen はビット数を倍にした型を返します。

x が値なら、xwiden(typeof(x)) に変換した値を返します。

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

Base.identity ── 関数

identity(x)

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

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

型のプロパティ

型の関係

Base.supertype ── 関数

supertype(T::DataType)
supertype(T::UnionAll)

T の上位型を返します。

julia> supertype(Int32)
Signed

Core.Type ── 型

Core.Type{T}

全ての型オブジェクトをインスタンスに持つ抽象型です。シングルトン型 Core.Type{T} は唯一のインスタンスとしてオブジェクト T を持ちます。

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

julia> isa(Float64, Type)
true

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

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

Core.DataType ── 型

DataType <: Type{T}

明示的に宣言される型を表します。DataType は名前と明示的に宣言される上位型、そして省略可能なパラメータを持ちます。Julia の型システムにおいて、全ての具象値は何らかの DataType のインスタンスです。

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType

Core.:<: ── 関数

<:(T1, T2)

部分型演算子です。T1 型の任意の値が T2 型でもあるとき、かつそのときに限って true を返します。

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

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

Base.:>: ── 関数

>:(T1, T2)

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

Base.typejoin ── 関数

typejoin(T, S)

TS の一番近い共通の先祖を返します。言い換えると、両方の型が継承している最も狭い型を返します。

Base.typeintersect ── 関数

typeintersect(T, S)

TS の交差を含む型を計算します。通常はそのような型の中で最小の型あるいは最小に近い型が返ります。

Base.promote_type ── 関数

promote_type(type1, type2)

昇格 (promotion) とは異なる型を持つ複数の値を一つの共通の型に変換することを言います。promote_type は演算子 (多くは数学演算子) に異なる型の引数が渡されたときの Julia デフォルトの昇格の振る舞いを表します。promote_type は一般に、入力の値を少なくとも近似できる型であって広すぎないものを返そうとします。多少の誤差は許容されます: 例えば promote_type(Int64, Float64)Float64 を返しますが、全ての Int64 の値が Float64 の値として正確に表せるわけではありません。

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

Base.promote_rule ── 関数

promote_rule(type1, type2)

promotetype1 型と type2 型の値が与えられたときに、昇格先として使うべき型を指定します。この関数を直接呼ぶべきではありませんが、新しい型に対する定義は必要に応じて追加するべきです。

Base.isdispatchtuple ── 関数

isdispatchtuple(T)

T が「葉型」のタプル型かどうかを判定します。タプル型が「葉型」とは、その型がディスパッチの型シグネチャに現れることができ、かつその部分型 (および上位型) は現れることができないことを意味します。

宣言構造体

Base.ismutable ── 関数

ismutable(v) -> Bool

v が可変なとき、かつそのときに限って true を返します。不変性について詳しくはマニュアルの可変複合型の節を参照してください。この関数は値に対して作用するので、型を与えるとその DataType 型の値が可変かどうかを答えます。

julia> ismutable(1)
false

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

この関数は Julia 1.5 以降でサポートされます。

Base.isimmutable ── 関数

isimmutable(v) -> Bool
注意

!ismutable(v) を使ってください。!ismutable(v) は将来のリリースで !ismutable(v) に置き換えられます (Julia 1.5 より)。

v が不変のとき、かつそのときに限って true を返します。不変性について詳しくはマニュアルの可変複合型の節を参照してください。この関数は値に対して作用するので、型を与えるとその DataType 型の値が不変かどうかを答えます。

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

Base.isabstracttype ── 関数

isabstracttype(T)

T が抽象型として (つまり abstract キーワードを使って) 宣言されたかどうかを判定します。

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

Base.isprimitivetype ── 関数

isprimitivetype(T) -> Bool

T がプリミティブ型として (つまり primitive キーワードを使って) 宣言されたかどうかを判定します。

Base.issingletontype ── 関数

Base.issingletontype(T)

T の可能なインスタンスが一つだけかどうかを判定します。例えばフィールドを持たない構造体型に対しては true を返します。

Base.isstructtype ── 関数

isstructtype(T) -> Bool

T が構造体型として (つまり struct キーワードまたは mutable struct キーワードを使って) 宣言されたかどうかを判定します。

Base.nameof ── メソッド

nameof(t::DataType) -> Symbol

DataType の名前をシンボルとして取得します。tUnionAll でラップされていても構いません。

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

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

Base.fieldnames ── 関数

fieldnames(x::DataType)

DataType のフィールド名からなるタプルを取得します。

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

Base.fieldname ── 関数

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

DataTypei 番目のフィールド名を取得します。

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

Base.hasfield ── 関数

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

Tname をフィールドに持つかどうかを示す真偽値を返します。

Julia 1.2

この関数は Julia 1.2 以降でサポートされます。

メモリレイアウト

Base.sizeof ── メソッド

sizeof(T::DataType)
sizeof(obj)

T に正準バイナリ表現が存在するなら、そのサイズを返します (単位はバイト)。TDataType 型の値でないなら、オブジェクト obj のサイズを返します (単位はバイト)。

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof([1.0:10.0;])
80

DataType 型の値 T が決まったサイズを持たないときはエラーが発生します。

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

Base.isconcretetype ── 関数

isconcretetype(T)

T が具象型かどうかを判定します。型 T が具象型とは、typeof(x) == T が成り立つ直接のインスタンス x が存在することを意味します。

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

julia> isconcretetype(Vector{Complex{Float32}})
true

julia> isconcretetype(Union{})
false

julia> isconcretetype(Union{Int,String})
false

Base.isbits ── 関数

isbits(x)

xisbitstype な型のインスタンスなら true を返します。

Base.isbitstype ── 関数

isbitstype(T)

T が “プレーンデータ型” なら true を返します。プレーンデータ型とは、プリミティブ型と他のプレーンデータ型だけを含み他の値を参照しない不変型を言います。典型的な例は UInt8, Float64, Complex{Float64} のような数値型です。このカテゴリに属する型は型パラメータとして利用でき、isdefinedisassigned のための追跡を必要とせず、C と互換性のあるレイアウトが定義されるので、このカテゴリは重要です。

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

Core.fieldtype ── 関数

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

複合型 T の指定されたフィールドが持つ宣言された型を返します。フィールドは名前もしくは位置で指定されます。

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

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

Base.fieldtypes ── 関数

fieldtypes(T::Type)

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

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

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

julia> fieldtypes(Foo)
(Int64, String)

Base.fieldcount ── 関数

fieldcount(t::Type)

与えられた型のインスタンスが持つことになるフィールドの個数を取得します。

Base.fieldoffset ── 関数

fieldoffset(type, i)

型のインスタンスを表すデータの開始地点から i 番目のフィールドまでのバイトオフセットを返します。次のようにすれば構造体の情報をまとめて表示できます:

julia> structinfo(T) = [(fieldoffset(T,i), fieldname(T,i), fieldtype(T,i))
                        for i = 1:fieldcount(T)];

julia> structinfo(Base.Filesystem.StatStruct)
12-element Array{Tuple{UInt64,Symbol,DataType},1}:
 (0x0000000000000000, :device, UInt64)
 (0x0000000000000008, :inode, UInt64)
 (0x0000000000000010, :mode, UInt64)
 (0x0000000000000018, :nlink, Int64)
 (0x0000000000000020, :uid, UInt64)
 (0x0000000000000028, :gid, UInt64)
 (0x0000000000000030, :rdev, UInt64)
 (0x0000000000000038, :size, Int64)
 (0x0000000000000040, :blksize, Int64)
 (0x0000000000000048, :blocks, Int64)
 (0x0000000000000050, :mtime, Float64)
 (0x0000000000000058, :ctime, Float64)

Base.datatype_alignment ── 関数

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

dt のインスタンスが持つ最小のメモリアラインメント要件を返します。任意の具象型に対して呼び出せます。

Base.datatype_haspadding ── 関数

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

dt のインスタンスのフィールドをパディングバイトを使わずにメモリに詰め込めるかどうかを判定し、パディングを持つなら true を返します。任意の具象型に対して呼び出せます。

Base.datatype_pointerfree ── 関数

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

dt のインスタンスが GC に管理されるメモリを指す参照を持つかどうかを判定し、持たないなら true を返します。任意の具象型に対して呼び出せます。

特殊な値

Base.typemin ── 関数

typemin(T)

与えれた (実) 数値型 T が表せる最小の値を返します。TDataType である必要があります。

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

Base.typemax ── 関数

typemax(T)

与えれた (実) 数値型 T が表せる最大の値を返します。TDataType である必要があります。

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

Base.floatmin ── 関数

floatmin(T=Float64)

浮動小数点数型 T で非正規化数を使わずに表現できる最小の正の値を返します。

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

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

Base.floatmax ── 関数

floatmax(T=Float64)

浮動小数点数型 T で表現できる最大の有限の値を返します。

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

Base.maxintfloat ── 関数

maxintfloat(T=Float64)

与えられた浮動小数点数型 T で浮動小数点数として正確に表現できる最大の整数値を返します。

言い換えると、maxintfloat が返すのは「n + 1 が型 T で正確に表せない」という条件を満たす正整数 n の中で最小のものを表す浮動小数点数です。

Integer 型の値が必要なときは Integer(maxintfloat(T)) としてください。

maxintfloat(T, S)

与えられた浮動小数点数型 T で表現できる連続する整数の中で、整数型 S の最大値を越さない最大値を返します。言い換えると、maxintfloat(T)typemax(S) の小さい方を返します。

Base.eps ── メソッド

eps(::Type{T}) where T<:AbstractFloat
eps()

浮動小数点数型 T計算機イプシロン (machine epsilon) を返します (デフォルトは T = Float64 です)。計算機イプシロンは「typeof(one(T)) で表現できる 1 の次に大きい値と 1 の差」として定義されます。この値は eps(one(T)) と等価です (eps(T)T 型の値が持つ相対的な誤差を抑える上界なので、one と同様に “次元を持たない” ため)。

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0

Base.eps ── メソッド

eps(x::AbstractFloat)

x の最下位桁の単位 (unit in last place, ulp) を返します。ulp は x と次の浮動小数点数の間の距離と定義されます。x と両隣の浮動小数点数間の距離は多くの場合で異なるので、大きい方が ulp として採用されます。つまり次の等式が成り立ちます:

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

この規則の例外は浮動小数点数の最大および最小の有限値 (例えば Float64 では nextfloat(-Inf)prevfloat(Inf)) です。この場合は小さい方の (有限の) 値が採用されます。

この振る舞いの理論的な根拠は、eps を使うと浮動小数点数の誤差を上から押さえられるという事実にあります。デフォルトの丸めモード RoundNearest を使うと、一般に実数 \(y\)\(y\) に一番近い浮動小数点数 \(x\) に対して次の不等式が成り立ちます:

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

julia> eps(1.0)
2.220446049250313e-16

julia> eps(prevfloat(2.0))
2.220446049250313e-16

julia> eps(2.0)
4.440892098500626e-16

julia> x = prevfloat(Inf)      # 最大の Float64
1.7976931348623157e308

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

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

Base.instances ── 関数

instances(T::Type)

与えられた型の全てのインスタンスのコレクションを返します。値が返るのはインスタンスの数が多すぎない場合のみです。通常は列挙体に対して使われます (参照: @enum)。

julia> @enum Color red blue green

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

特殊な型

Core.Any ── 型

Any::DataType

Any は全ての型の和です。任意の x に対して isa(x, Any) == true が成り立ちます。つまり Any が表す値の集合は Julia の宇宙に存在する可能な値全てを含みます。例えば Any の部分集合の一つとして Integer があり、その中に Int, Int8 といった整数型が存在します。

Core.Union ── 型

Union{Types...}

型共用体 (type union) は各引数の型のインスタンスを全て含む抽象型です。空の型共用体 Union{} は Julia の型システムにおけるボトム型です。

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

julia> 1 :: IntOrString
1

julia> "Hello!" :: IntOrString
"Hello!"

julia> 1.0 :: IntOrString
ERROR: TypeError: in typeassert, expected Union{Int64, AbstractString}, got a value of type Float64

Union{} ── キーワード

Union{}

空の UnionUnion{} は値を持たない型です。つまり、isa(x, Union{}) == false が任意の x に対して成り立つという性質によって特徴付けられます。Union{} の別名として Base.Bottom が定義され、Union{}Core.TypeofBottom という型を持ちます。

julia> isa(nothing, Union{})
false

Core.UnionAll ── 型

UnionAll

型パラメータが取り得るそれぞれの値に対する型の共用体を表す型です。UnionAll はパラメータの値がまだ知られていないパラメトリック型を表すのに使われます。

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Core.Tuple ── 型

Tuple{Types...}

タプルは関数の引数の抽象化です ──関数の処理は含まれません。関数の引数の最も重要な性質は順序と型です。そのためタプル型はパラメータ化された不変型であり、各パラメータが一つのフィールドの型を表します。タプルは好きなだけ多くのパラメータを持つことができます。

タプル型はパラメータの型に関して共変 (covariant) であり、例えば Tuple{Int}Tuple{Any} の部分型です。そのため Tuple{Any} は抽象型とみなされ、タプル型はパラメータが全て具象型であるときだけ具象型となります。またタプルはフィールド名を持たず、フィールドには位置によってのみアクセスできます。

マニュアルのタプル型の節も参照してください。

Core.NamedTuple ── 型

NamedTuple

NamedTuple は、名前が示す通り、名前の付いた Tuple です。つまり NamedTupleTuple と同じく値のコレクションですが、それぞれのエントリに Symbol で表されるユニークな名前が付いています。Tuple と同様 NamedTuple は不変です: 名前と値はどちらも構築した後に変更できません。

名前付きタプルにおける名前に関連付いた値へのアクセスは、フィールドアクセス構文 x.a または getindex (x[:a]) を使って行います。名前付きタプルの名前を集めたタプルは keys で取得でき、値を集めたタプルは values で取得できます。

情報

NamedTuple に対して反復を行うと、名前を使わずに values だけを取り出せます (以下の例を参照)。名前と値の組に関して反復するには pairs 関数を使ってください。

@NamedTuple マクロを使うと NamedTuple 型を簡単に宣言できます。

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

julia> x.a
1

julia> x[:a]
1

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

julia> values(x)
(1, 2)

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

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

キーワード引数の名前と値をプログラムから設定できるのと同じように、名前付きタプルはタプルリテラルの中に置いたセミコロンの後に name::Symbol => value という組を与えることでも作成できます。あるいは反復子を崩してこの形の組を作り、その組から名前付きタプルを作ることもできます:

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

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

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

キーワード引数と同様に、セミコロンを使ったこの形のリテラルで識別子やドット式を使うと、エントリの名前がそこから取り出されます:

julia> x = 0
0

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

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

名前付きタプルのリテラルで識別子とドット式から自動的に名前を取り出す機能は Julia 1.5 以降で利用できます。

[email protected] ── マクロ

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

このマクロは NamedTuple 型を宣言する便利な構文を提供します。@NameTuple が返すのは与えられたキーと型を持つ NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}} と等価な NamedTuple 型です。::Type の宣言を省略すると Any とみなされます。begin ... end の形式では型の宣言を複数行に分けて struct の宣言のように書くことができます。二つの書き方にそれ以外の違いはありません。

名前付きタプル (a=3.1, b="hello")NamedTuple{(:a,:b), Tuple{Float64,String}} という型を持ちますが、@NamedTuple を使ってこの型を宣言するには次のようにします:

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

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

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

Base.Val ── 型

Val(c)

実行時データを持たない値 Val{c}() を返します。cisbits な値である必要があります。この種の型は値 c を通して関数の間で情報を受け渡すために利用できます。この構文を使うのは、定数に対して (コンパイル時に) 直接ディスパッチを行うことで実行時に定数の値を確認を省くためです。

julia> f(::Val{true}) = "Good"
f (generic function with 1 method)

julia> f(::Val{false}) = "Bad"
f (generic function with 2 methods)

julia> f(Val(true))
"Good"

Core.Vararg ── 型

Vararg{T,N}

Tuple 型の最後のパラメータは任意個数の要素を表す特殊な型 Vararg とできます。Vararg{T, N} という型はちょうど N 個の T 型の要素に対応し、Vararg{T} という型はゼロ個以上の T 型の要素に対応します。Vararg を持つタプル型は可変長引数メソッドが受け取る引数を表します (詳細はマニュアルの可変長引数関数の節を参照してください)。

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

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

Core.Nothing ── 型

Nothing

nothing の型です。フィールドを持ちません。

Base.isnothing ── 関数

isnothing(x)

x === nothing なら true を返し、そうでないなら false を返します。

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

Base.Some ── 型

Some{T}

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

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

Base.something ── 関数

something(x, y...)

引数の中で nothing と等しくない最初の値を返します。もし引数が全て nothing ならエラーが発生します。Some 型の引数はアンラップされます。

coalesce も参照してください。

julia> something(nothing, 1)
1

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

julia> something(missing, nothing)
missing

julia> something(nothing, nothing)
ERROR: ArgumentError: No value arguments present

Base.Enums.Enum ── 型

Enum{T<:Integer}

@enum で定義される任意の列挙型の上位型となる抽象型です。

[email protected] ── マクロ

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

value1, value2, ... をメンバーに持つ EnumName という名前の列挙型 (Enum{BaseType} の部分型) を作成します。value1, value2, ... にはそれぞれ x, y, ... という値が割り当てられます。EnumName は通常の型のように利用でき、そのメンバーは通常の値のように利用できます。

julia> @enum Fruit apple=1 orange=2 kiwi=3

julia> f(x::Fruit) = "I'm a Fruit with value: $(Int(x))"
f (generic function with 1 method)

julia> f(apple)
"I'm a Fruit with value: 1"

julia> Fruit(1)
apple::Fruit = 1

メンバーを begin ブロックで指定することもできます:

@enum EnumName begin
    value1
    value2
end

BaseTypeInterger の部分プリミティブ型である必要があり、省略すると Int32 が使われます。メンバーの値は列挙体の型から BaseType への変換がサポートされ、readwirte は変換を自動的に行います。

列挙体の全てのインスタンスを取得するには instances を使ってください:

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

Core.Expr ── 型

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

Julia コードのパース結果に含まれる複合式 (AST) を表す型です。それぞれの式は種別 (関数呼び出し・for ループ・条件式など) を表すシンボル head と、付随する部分式 (関数呼び出しの引数など) からなります。部分式は Vector{Any} 型のフィールド args に保存されます。

詳細はマニュアルのメタプログラミングの章および開発者向けドキュメントの Julia の AST を参照してください。

julia> Expr(:call, :+, 1, 2)
:(1 + 2)

julia> dump(:(a ? b : c))
Expr
  head: Symbol if
  args: Array{Any}((3,))
    1: Symbol a
    2: Symbol b
    3: Symbol c

Core.Symbol ── 型

Symbol

Julia コードのパース結果 (AST) に含まれる識別子を表すオブジェクトの型です。何らかの要素を特定するためのラベル (例えば辞書のキー) としても使われます。Symbol はクオート演算子 : を使って入力します:

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

コンストラクタ Symbol(x...) を使えば文字列などの値からも Symbol を構築できます。

Symbol は不変オブジェクトであり、比較は === を使って行うべきです。実装では同じ名前の Symbol が同じオブジェクトで表されるので、比較が高速に行えます (ポインタを比べれば済むため)。

文字列とは異なり、Symbol は “不可分” で “スカラー” な値なので、各文字に対する反復をサポートしません。

Core.Symbol ── メソッド

Symbol(x...) -> Symbol

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

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

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

Core.Module ── 型

Module

Module は独立したグローバル変数のワークスペースです。詳細は module およびマニュアルのモジュールの章を参照してください。

総称関数

Core.Function ── 型

Function

任意の関数を表す抽象型です。

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin)

julia> ans <: Function
true

Base.hasmethod ── 関数

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

総称関数 f のメソッドの中に、タプル t を引数として受け取ることができ、かつ世界時 world より前に定義されたものが存在するかどうかを判定します。

タプルのキーワード引数 kwnames が与えられると、t にマッチする f のメソッドが kwnames に含まれるキーワード引数を持つかどうかが判定されます。もしマッチするメソッドが可変長のキーワード引数を受け取る (;kwargs... などとなっている) なら、kwnames に含まれる任意の名前は正当とみなされます。それ以外の場合には、与えられた名前がメソッドのキーワード引数の部分集合である場合に限って true が返ります。

applicable も参照してください。

Julia 1.2

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

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

julia> hasmethod(sum, Tuple{Function, Array}, (:dims,))
true

julia> hasmethod(sum, Tuple{Function, Array}, (:apples, :bananas))
false

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

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g は任意のキーワード引数を受け取る。
true

Core.applicable ── 関数

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

総称関数 f を引数 args に対して適用できるかどうかを判定します。

hasmethod も参照してください。

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

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true

Core.invoke ── 関数

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

argtypes にマッチする総称関数 f のメソッドを、位置引数 args とキーワード引数 kwargs を渡して呼び出します。args の型は argtypes で指定した型と一致する必要があり、自動的な変換は行われません。このメソッドを使うと、最も特定的でないメソッドを呼び出すことが可能になります。この機能は一般的に定義される振る舞いが明示的に必要になったときに有用です (一般的なメソッドを持つ関数の特定的なメソッドの実装でよく使われます)。

自分が書いていない関数に対して invoke を使うときは注意が必要です。関数を特定の argtypes 型で呼び出すことがパブリックな API であることが明言されていない限り、与えられた argtypes に対して使われるメソッド定義は実装詳細です。例えば以下のコードで f1f2 は通常の (invoke を使わない) 呼び出しで区別できないので、通常は違いはないとみなされます。しかし invoke を使うと違った結果が得られます。

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

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

julia> f(2)
5

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

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

julia> f1(1)
Integer

julia> f2(1)
Integer

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

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

Base.invokelatest ── 関数

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

f(args...; kwargs...) を呼び出します。invokelatest を使うと、最新の f のメソッドが呼ばれることが保証されます。これは関数が特殊化される状況、例えば長い間実行されるイベントループやコールバック関数で古い f の定義を呼び出される可能性がある状況で有用です (ただし欠点として、invokelatestf を直接呼び出すよりもいくらか遅く、コンパイラは返り値の型を推論できません)。

new ── キーワード

new

内部コンストラクタメソッドで自身の型の新しいオブジェクトを作るときに利用できる特殊な関数です。詳細はマニュアルの内部コンストラクタメソッドの節を参照してください。

Base.:|> ── 関数

|>(x, f)

前にある引数 x に関数 f を適用します。関数のチェーン表記が可能になります。

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

Base.:∘ ── 関数

f ∘ g

関数を合成します。つまり (f ∘ g)(args...)f(g(args...)) と等価です。記号 は REPL (および適切に設定されたその他のエディタ) で \circ<TAB> とタイプすれば入力できます。

関数の合成は前置形式でも行うことができ、∘(f, g)f ∘ g と同じです。前置形式には複数の関数の合成をサポートするので、∘(f, g, h) = f ∘ g ∘ h が成り立ちます。さらに splat 演算子を使って ∘(fs...) とすれば関数の反復可能コレクションに含まれる関数を合成できます。

Julia 1.4

複数の関数の合成は Julia 1.4 以降でサポートされます。

Julia 1.5

一つの関数の合成 ∘(f) は Julia 1.5 以降でサポートされます。

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

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

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

構文

Core.eval ── 関数

Core.eval(m::Module, expr)

与えられたモジュール m で式 expr を評価し、評価結果を返します。

Base.MainInclude.eval ── 関数

eval(expr)

この関数を持つモジュールのグローバルスコープで式 expr を評価します。(baremodule として定義されたモジュールを除く) 全てのモジュールは、受け取った式を自身のモジュールで評価する一変数の eval の定義をそれぞれ持ちます。

[email protected] ── マクロ

@eval [mod,] ex

exeval で評価します。評価は ex 内の補間が計算されてから行われます。二つの引数が与えられると、第一引数のモジュールで評価を行います。

Base.evalfile ── 関数

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

include を使ってファイルを読み込みます。式を全て評価し、最後の式の評価結果を返します。

Base.esc ── 関数

esc(e)

マクロが返す Expr の文脈でのみ利用できます。マクロの健全性パスが e に埋め込まれた変数を gensym 変数に変形しなくなります。詳細はマニュアルのマクロの節を参照してください。

[email protected] ── マクロ

@inbounds(blk)

blk 中で配列の境界検査を無効化します。

次の例では配列 Ai 番目の要素へアクセスするときの境界検査が飛ばされるので、性能が向上します:

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i = 1:length(A)
        @inbounds r += A[i]
    end
    return r
end
注意

@inbounds を使った式の中で境界外アクセスを行うと、正しくない結果が返ったり、プログラムのクラッシュやメモリの破壊が起きる可能性があります。境界外アクセスを起こらないことを手動で確認するのはユーザーの責任です。@inbounds は全てのアクセスが境界内であることがローカルで利用可能な情報から明らかな場合にだけ使ってください。

[email protected] ── マクロ

@boundscheck(blk)

blk に「この式は境界検査を行うブロックである」という注釈を付けます。この注釈が付いた式は @inbounds で削除されます。

情報

@boundscheck ブロックを持つ関数を @inbounds 式から呼ぶとき、@inbounds が効果を持つ (呼び出した関数内の @boundscheck が削除される) には、その関数がインライン化される必要があります。

julia> @inline function g(A, i)
           @boundscheck checkbounds(A, i)
           return "accessing ($A)[$i]"
       end;

julia> f1() = return g(1:2, -1);

julia> f2() = @inbounds return g(1:2, -1);

julia> f1()
ERROR: BoundsError: attempt to access 2-element UnitRange{Int64} at index [-1]
Stacktrace:
 [1] throw_boundserror(::UnitRange{Int64}, ::Tuple{Int64}) at ./abstractarray.jl:455
 [2] checkbounds at ./abstractarray.jl:420 [inlined]
 [3] g at ./none:2 [inlined]
 [4] f1() at ./none:1
 [5] top-level scope

julia> f2()
"accessing (1:2)[-1]"
注意

ライブラリを書くときに @boundscheck 注釈を使うと、他のコードから @inbounds を使って境界検査を削除するオプトインの選択肢を提供できます。上述の通り、呼び出し側は @inbounds を付ける前にアクセスが正当であることを ──アクセスできる情報を利用して── 確認する必要があります。例えば AbstractArray の部分型に対する添え字アクセスでは、境界検査で添え字を size と比較する処理を行います。そのため @boundscheckgetindexsetindex! の実装だけに、その振る舞いが正しいことを確認してから付けるべきです。

[email protected]_inbounds ── マクロ

@propagate_inbounds

呼び出し側の @inbounds コンテキストを保持したまま関数をインライン化するようコンパイラに伝えます。

[email protected] ── マクロ

@inline

「この関数はインライン化した方がよい」というヒントをコンパイラに与えます。

通常コンパイラは小さい関数に対して自動的にインライン化を行うので、小さい関数に @inline は必要ありません。@inline を大きい関数に付けることで、それをインライン化するようコンパイラに促すことができます。次の例のように使います:

@inline function bigfunction(x)
    #=
        関数の定義
    =#
end

[email protected] ── マクロ

@noinline

「この関数はインライン化しない方がよい」というヒントをコンパイラに与えます。

小さい関数は通常、自動的にインライン化されます。@noinline を小さい関数に使うことで、自動的なインライン化を抑止できます。次の例のように使います:

@noinline function smallfunction(x)
    #=
        Function Definition
    =#
end

関数が自明 (例えば定数を返すだけ) だと、@noinline を付けてもインラインされて消える可能性があります。

[email protected] ── マクロ

@nospecialize

関数の引数の名前に適用され、コンパイラに「この引数の型に対しては特殊化を行わず、引数宣言に与えられた型をそのまま使うべきである」というヒントを与えます。これは過剰なコード生成を避けるための単なるヒントです。この注釈は関数の定義で使う引数リストの中で与えることも、関数本体で与えることもできます。引数リスト内で引数に適用するときは引数の式全体を @nospecialize で囲む必要があり、関数の本体で使うときは @nospecialize を最初の文にする必要があります。

@nospecialize を引数を付けずに使うと、親のスコープに含まれる全ての引数に適用されます。つまりローカルスコープでは @nospecialize を含む関数の全ての引数に適用され、グローバル (トップレベル) スコープでは現在のモジュールでこれから定義される全てのメソッドに適用されます。

@specialize を使うと特殊化の挙動を元に戻せます。

function example_function(@nospecialize x)
    ...
end

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

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

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

[email protected] ── マクロ

@specialize

引数に対する特殊化ヒントをデフォルトに戻します。詳細は @nospecialize を参照してください。

Base.gensym ── 関数

gensym([tag])

他の変数の名前と衝突しないシンボルを生成します。tag (文字列またはシンボル) を与えると、#$tag# がシンボルの前に連結されます。

[email protected] ── マクロ

@gensym

与えられた名前を gensym に入力してシンボルを生成し、それを同名の変数に代入します。例えば @gensym x yx = gensym("x"); y = gensym("y") に変換されます。

var"name" ── キーワード

var

var"#example#" という構文は #example# という名前の変数を表します。ただし #example# は Julia の識別子名としては正当ではありません。

この構文は構文や正当な識別子に関して Julia と異なる規則を持つプログラミング言語との相互運用で有用です。例えば R の変数 draw.segments を参照するときは、Julia コードからは var"draw.segments" を使います。

マクロの健全性処理を行った後の Julia ソースコードを show したときにも、このマクロは表れます。マクロ展開で追加される変数の名前は通常通りパースできないためです。

この構文を処理するにはパーサーが割って入る必要があることに注意してください。この構文はパーサーが直接展開しなければならないので、通常の文字列マクロ @var_str として実装することはできません。

Julia 1.3

この構文は Julia 1.3 以降でサポートされます。

[email protected] ── マクロ

@goto name

@goto name@label name の位置にある文へ無条件に制御を移動させます。

@label@goto を使ってトップレベルの文へジャンプすることはできず、行うとエラーが発生します。どうしてもトップレベルで @goto を使いたいなら、@label@goto をブロックで囲ってください。

[email protected] ── マクロ

@label name

文にシンボルを使ったラベル name を付けます。このラベルは @goto name を使った無条件ジャンプの目的地となります。

[email protected] ── マクロ

@simd

通常より踏み込んだループ交換を行う許可をコンパイラに与える注釈を for ループに付けます。

注意

この機能は実験的であり、将来のバージョンの Julia で変更/削除される可能性があります。間違った方法で @simd マクロを使うと予期せぬ結果が得られることがあります。

@simd for ループが反復するオブジェクトは一次元配列であるべきです。@simd を使うと、ループに関する次の性質が仮定されます:

  • 縮約変数さえ考慮すれば、各反復を任意の順序で、互いに重なる形で実行して構わない。
  • 縮約変数に対する浮動小数点数演算の順序は交換して構わない (これによって @simd を使わないときと異なる結果となっても構わない)。

Julia は多くの場合で、@simd が無くても内側の for ループを自動的にベクトル化します。@simd を使うとコンパイラがベクトル化できるかを判断する条件を緩めることができ、ベクトル化が行える状況が増えます。両方の場合で、コンパイラによるベクトル化のためには内側のループに次の性質が必要です:

  • そのループが最も内側のループである。
  • ループの本体が直線的なコードである (条件分岐を全く持たない)。例えば現在の実装では配列へのアクセスには全て @inbounds が付いている必要がある。&&, ||, ?: を使った短い式であれば、コンパイラがオペランドを無条件に評価しても安全であることを確認できるなら直線的なコードに変換できることがある。安全に変換できるときは ?: ではなく ifelse を使うことが推奨される。
  • アクセスが “stride” パターンを持っている (隣り合う反復が定数だけ離れた読み書きを行う)。“gather” (ランダムな添え字からの読み込み) や “scatter” (ランダムな添え字への書き込み) は許されない。
  • 歩長が一定 (unit stride) である。
情報

ループの反復の間に存在するメモリの依存関係が存在しないことを、@simd はデフォルトで確認しません。この仮定は汎用なコードで簡単に破られます。汎用でないコードを書くときは、@simd ivdep for ... end を使えば次の事実を追加で表明 (成り立つものとして最適化を進めるようコンパイラに指示) できます:

  • 反復をまたいだメモリの依存関係が存在しないこと。
  • 実行を進めるために以前の反復を待つ必要がある反復が存在しないこと。

[email protected] ── マクロ

@polly

ポリヘドラルオプティマイザ Polly による最適化を関数に適用するようコンパイラに指示します。

[email protected] ── マクロ

@generated f
@generated(f)

@generated は関数が後から生成される (被生成関数である) ことを示す注釈です。被生成関数の本体では、引数の型だけを読むことができます (値は読めません)。被生成関数はクオートされた式を返し、その式が関数が呼ばれたときに評価されます。グローバルスコープを変更する関数や可変要素に依存する関数に対しては @generated マクロを使用するべきではありません。

詳細はマニュアルの被生成関数の節を参照してください。

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

julia> bar(4)
16

julia> bar("baz")
"baz"

[email protected] ── マクロ

@pure ex
@pure(ex)

@pure は定義されている関数が純粋であることを示すヒントをコンパイラに与えます。これによって型推論の精度が向上する場合があります。

純粋関数が依存できるのは不変な情報だけです。これは @pure が付いた関数がグローバルな可変状態を利用できないことを意味します。利用できない状態には総称関数も含まれます。@pure は注意して使ってください。誤った使い方をすると、見つけるのが困難なバグが起こる可能性があります。特に総称関数を呼び出していないことの注意深い確認が必要です。このマクロはコンパイラ内部での利用が意図されており、将来変更される可能性があります。

[email protected] ── マクロ

@deprecate old new [ex=true]

メソッド old を非推奨として、代替として new を指定します。exfalse にすると、old がエクスポートされなくなります。@deprecateold と同じシグネチャを持つ新しいメソッドを定義します。

Julia 1.5

Julia 1.5 でコマンドライン引数 --depwarn のデフォルト値が no になったので、julia--depwarn=yes を指定しないで起動すると @deprecate が定義する関数に対する警告が出力されません。Pkg.test() でテストを実行するときは警告が発生します。

julia> @deprecate old(x) new(x)
old (generic function with 1 method)

julia> @deprecate old(x) new(x) false
old (generic function with 1 method)

欠損値

Base.Missing ── 型

Missing

missing をシングルトンのインスタンスとして持つ型です。欠損値を表すのに利用されます。

Base.missing ── 定数

missing

Missing 型のシングルトンのインスタンスです。欠損値を表します。

Base.coalesce ── 関数

coalesce(x, y...)

引数の中で missing でない最初の値を返します。もし全て missing なら、missing を返します。

something も参照してください。

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # nothing が返る。

julia> coalesce(missing, missing)
missing

Base.ismissing ── 関数

ismissing(x)

xmissing かどうかを判定します。

Base.skipmissing ── 関数

skipmissing(itr)

itrmissing でない要素を反復する反復子を返します。itr が添え字アクセスをサポートするなら、skipmissing が返すオブジェクトには itr の添え字を使ってアクセスできます。itr の欠損値に対応する添え字は正当ではなく、keyseachindex はその添え字を無視します。また欠損値を指す添え字を使うと MissingException が発生します。

itr に含まれる missing でない値からなる Array を取得するには collect を使ってください。なお itr が多次元配列であっても collect の返り値は Vector であることに注意が必要です。入力の次元を保ったままでは欠損値を取り除けないためです。

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 Array{Int64,1}:
 1
 3

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

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

Base.nonmissingtype ── 関数

nonmissingtype(T::Type)

TMissing を含む型共用体なら、Missing を削除した新しい型を返します。そうでなければ T を返します。

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

julia> nonmissingtype(Any)
Any
Julia 1.3

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

システム

Base.run ── 関数

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

バックティックで構築したコマンドオブジェクトを実行します。waittrue のときにプロセスが 0でない終了コードを返した場合など、何か上手く行かなければエラーが発生します (詳細はマニュアルの外部プログラムの実行の章を参照してください)。

waitfalse だと、プロセスは非同期に実行されます。後でプロセスの終了を待って終了状態を取得するには、run が返すプロセスオブジェクトに対して success を呼んでください。

waitfalse なら、プロセスの IO ストリームは devnull に転送されます。waittrue なら、IO ストリームは親プロセスと共有されます。IO リダイレクトの制御には pipeline が利用できます。

Base.devnull ── 定数

devnull

ストリームを devnull にリダイレクトすると、書き込まれたデータが全て捨てられます。本質的に Unix では /dev/null と等価であり、Windows では NUL と等価です。使用例を示します:

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

Base.success ── 関数

success(command)

バックティックで構築したコマンドオブジェクトを実行し、それが成功 (終了コード 0 で終了) したかどうかを判定します (詳細はマニュアルの外部プログラムの実行の章を参照してください)。プロセスを開始できないときはエラーが発生します。

Base.process_running ── 関数

process_running(p::Process)

プロセスが現在実行中かどうかを判定します。

Base.process_exited ── 関数

process_exited(p::Process)

プロセスが終了したかどうかを判定します。

Base.kill ── メソッド

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

プロセスへシグナルを送信します。デフォルトではプロセスを終了させるシグナルが送信されます。プロセスが既に終了していた場合には成功しますが、プロセスの kill が他の理由 (権限の不足など) で失敗した場合にはエラーが発生します。

Base.Sys.set_process_title ── 関数

Sys.set_process_title(title::AbstractString)

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

Base.Sys.get_process_title ── 関数

Sys.get_process_title()

プロセスのタイトルを取得します。一部のオペレーティングシステムでは常に空文字列を返します。

Base.ignorestatus ── 関数

ignorestatus(command)

コマンドの終了コードが 0 でなくてもエラーを発生させない印をコマンドオブジェクトに付けます。

Base.detach ── 関数

detach(command)

コマンドを新しいプロセスグループで実行する印をコマンドオブジェクトに付けます。この印を付けたオブジェクトを実行するプロセスは Julia より長く生存し、Julia に対して Ctrl-C を送ってもそのプロセスには伝わらなくなります。

Base.Cmd ── 型

Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)

外部プログラムとその引数を表す Cmd オブジェクトを構築します。構築は cmd を使って行われ、省略可能なキーワード引数で設定が変更されます:

  • ignorestatus::Bool: もし true なら、Cmd0 でない終了コードで終了してもエラーが発生しなくなります。デフォルトは false です。
  • detach::Bool: もし true なら、Cmd が新しいプロセスグループで実行されます。つまり Cmd を実行するプロセスは Julia より長く生きられるようになり、Julia に対して Ctrl-C を送ってもそのプロセスには伝わりません。デフォルトは false です。
  • windows_verbatim::Bool: もし true なら、Windows で Cmd がプロセスに送るコマンドライン文字列に空白が含まれていたとしてもクオートやエスケープが行われなくなります。デフォルトは false です。Windows ではコマンドライン引数が単一の「コマンドライン文字列」としてプログラムに送られ、それを引数にパースするのはプログラムの責任となっています。デフォルトでは空白やタブを含む引数や空の引数は二重引用符 " を使ってクオートされ、\" には \ でエスケープされます。windows_verbatim=true は標準的でない方法でコマンドラインをパースするプログラムを起動するときに有用です。このキーワード引数は Windows 以外で意味を持ちません。
  • windows_hide::Bool: もし true なら、Windows で Cmd を実行するときに新しいコンソールウィンドウが表示されなくなります。コンソールが既に開いているとき、および Windows 以外のシステムでは効果を持ちません。デフォルトは false です。
  • env: Cmd の実行中に設定される環境変数です。env は文字列から文字列への辞書か、"var=val" という形の文字列からなる配列か、"var"=>val という組からなるタプルまたは配列か、nothing のいずれかです。環境変数を全て置き換えるのではなく既存の環境変数を一部変更するには、copy(ENV) としてから env["var"]=val として変更したものを env として使ってください。
  • dir::AbstractString: コマンドの作業ディレクトリを指定します (指定しなければカレントディレクトリが使われます)。

指定しないキーワードについては cmd が持つ設定が使われます。通常 cmd に渡す Cmd オブジェクトはバックティックを使って作成されます:

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

Base.setenv ── 関数

setenv(command::Cmd, env; dir="")

与えられた command を実行するときに使うべき環境変数を設定します。env は文字列から文字列への辞書か、"var=val" という形の文字列からなる配列か、"var"=>val という組からなるタプルまたは配列か、nothing のいずれかです。環境変数を全て置き換えるのではなく既存の環境変数を一部変更するには、copy(ENV) としてから env["var"]=val として変更したものを env として使ってください。あるいは withenv を使うこともできます。

dir はコマンドの作業ディレクトリを指定します。

Base.withenv ── 関数

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

現在の環境変数を "var"=>val という形をしたゼロ個以上の引数 kv を使って一時的に変更した状態で f を実行します (setenv とは異なり、環境変数が引数で置き換わるわけではありません)。withenv は通常 withenv(kv...) do ... end という構文で使われます。現在値を持つ環境変数の値に nothing を指定すると、その変数を一時的に削除できます。環境変数は withenv が返るとき元の値に復元されます。

Base.pipeline ── メソッド

pipeline(from, to, ...)

前の要素からデータを読み、次の要素へデータを書き込むパイプラインを作成します。パイプラインの要素に指定できるのはコマンドまたは文字列、もしくは他の pipeline が返した値のいずれかであり、少なくとも一つはコマンドである必要があります。文字列はファイル名を表します。二つ以上の引数を与えて呼び出すと、各要素が左から右に連結します。例えば pipeline(a,b,c)pipeline(pipeline(a,b),c) と等価です。この機能を使えば複数のステージからなるパイプラインを簡単に記述できます。

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))

Base.pipeline ── メソッド

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

与えられた command が行う IO のリダイレクトを設定します。キーワード引数 stdin, stdout, stdout がコマンドが持つストリームのリダイレクト先を指定し、append がファイルへの出力が追記されるかどうかを制御します。これは二引数の pipeline 関数をより一般的にしたものです。例えば from がコマンドのときの pipeline(from, to)pipeline(from, stdout=to) と等価であり、from が他の種類のデータソースなら pipeline(to, stdin=from) と等価です。

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

Base.Libc.gethostname ── 関数

gethostname() -> AbstractString

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

Base.Libc.getpid ── 関数

getpid(process) -> Int32

子プロセス process が存在するなら、そのプロセス ID を取得します。

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

getpid() -> Int32

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

Base.Libc.time ── メソッド

time()

エポックからの経過秒数をシステムから取得します。非常に高い分解能 (通常はマイクロ秒) を持ちます。

Base.time_ns ── 関数

time_ns()

時刻を取得します。単位はナノ秒です。0 に対応する時刻は不定であり、この関数が返す時刻はおよそ 5.8 年ごとに同じ値を取ります。

[email protected] ── マクロ

@time

式を実行し、実行にかかった時間・メモリアロケートの回数・アロケートされたメモリの総量を出力し、式の値を返します。

@timev, @timed, @elapsed, @allocated も参照してください。

情報

より本格的なベンチマークでは BenchmarkTools.jl パッケージの @btime マクロの利用を検討してください。@btime は関数を複数回実行してノイズを削減するといった処理を行います。

julia> @time rand(10^6);
  0.001525 seconds (7 allocations: 7.630 MiB)

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

[email protected] ── マクロ

@timev

詳細なバージョンの @time マクロです。@time と同じ情報に加えてメモリアロケートに関する様々なカウンタの中でゼロでない値を持つものを出力し、式の値を返します。

@time, @timed, @elapsed, @allocated も参照してください。

julia> @timev rand(10^6);
  0.001006 seconds (7 allocations: 7.630 MiB)
elapsed time (ns): 1005567
bytes allocated:   8000256
pool allocs:       6
malloc() calls:    1

[email protected] ── マクロ

@timed

式を実行し、式の値・かかった時間・アロケートされたメモリの総量・ガベージコレクションにかかった時間・メモリアロケートに関する様々なカウンタを持つオブジェクトを返します。

@time, @timev, @elapsed, @allocated も参照してください。

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

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

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

julia> stats.gcstats.total_time
5576500
Julia 1.5

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

[email protected] ── マクロ

@elapsed

式を実行し、返り値を捨て、かかった秒数を浮動小数点数として返します。

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

julia> @elapsed sleep(0.3)
0.301391426

[email protected] ── マクロ

@allocated

式を評価し、返り値を捨て、式の評価中にアロケートされたメモリの量を返します (単位はバイト)。

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

julia> @allocated rand(10^6)
8000080

Base.EnvDict ── 型

EnvDict() -> EnvDict

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

Base.ENV ── 定数

ENV

EnvDict のシングルトンを指す参照です。システムの環境変数に対する辞書を使ったインターフェースを提供します。

Windows ではシステムの環境変数が大文字と小文字を区別しないので、ENV を表示・反復・コピーするとキーが全て大文字に変換されます。ポータブルなコードは環境変数の大文字と小文字を区別する処理を行うべきではありません。また小文字の変数を設定する処理を行っても大文字の ENV キーが設定される可能性も念頭に置くべきです。

Base.Sys.isunix ── 関数

Sys.isunix([os])

OS が Unix 風のインターフェースを提供するかどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

Base.Sys.isapple ── 関数

Sys.isapple([os])

OS が Apple Macintosh OS X 系列または Darwin 系列であるかどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

Base.Sys.islinux ── 関数

Sys.islinux([os])

OS が Linux 系列かどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

Base.Sys.isbsd ── 関数

Sys.isbsd([os])

OS が BSD 系列かどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

情報

Darwin カーネルは BSD を元にしているので、mac OS システムで Sys.isbds()true となります。判定から macOS を除外するには Sys.isbsd() && !Sys.isapple() としてください。

Base.Sys.isfreebsd ── 関数

Sys.isfreebsd([os])

OS が FreeBSD 系列かどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

情報

Sys.isfreebsd()Sys.isbsd() を混同しないように注意してください。Sys.isbsd は FreeBSD で true となりますが、他の BSD ベースのシステムでも true になります。Sys.isfreebsd は FreeBSD だけを指します。

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

Base.Sys.isopenbsd ── 関数

Sys.isopenbsd([os])

OS が OpenBSD 系列かどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

情報

Sys.isopenbsd()Sys.isbsd() を混同しないように注意してください。Sys.isbsd は OpenBSD で true となりますが、他の BSD ベースのシステムでも true になります。Sys.isopenbsd は OpenBSD だけを指します。

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

Base.Sys.isnetbsd ── 関数

Sys.isnetbsd([os])

OS が NetBSD 系列かどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

情報

Sys.isnetbsd()Sys.isbsd() を混同しないように注意してください。Sys.isbsd は NetBSD で true となりますが、他の BSD ベースのシステムでも true になります。Sys.isnetbsd は NetBSD だけを指します。

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

Base.Sys.isdragonfly ── 関数

Sys.isdragonfly([os])

OS が DragonFly BSD 系列かどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

情報

Sys.isdragonfly()Sys.isbsd() を混同しないように注意してください。Sys.isbsd は DragonFly で true となりますが、他の BSD ベースのシステムでも true になります。Sys.isdragonfly() は DragonFly だけを指します。

Julia 1.1

この関数は Julia 1.1 以降でサポートされます。

Base.Sys.iswindows ── 関数

Sys.iswindows([os])

OS が Microsoft Windows NT 系列かどうかを判定します。詳細はマニュアルの OS 間の差異の章を参照してください。

Base.Sys.windows_version ── 関数

Sys.windows_version()

Windows NT Kernel のバージョン番号を v"major.minor.build" のような VersionNumber オブジェクトとして返します。Windows で実行していなければ v"0.0.0" が返ります。

Base.Sys.free_memory ── 関数

Sys.free_memory()

空いている RAM の容量を返します (単位はバイト)。

Base.Sys.total_memory ── 関数

Sys.total_memory()

RAM の総容量を取得します (単位はバイト)。現在使われている部分の容量を含みます。

[email protected] ── マクロ

@static

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

例えば @static Sys.iswindows() ? foo : bar とすると Sys.iswindows() が評価され、foo または bar が現在の式に挿入されます。これは対応していないプラットフォームで存在しない関数に対する ccall などの不正な構文となってしまうときに利用できます。同様に @static if Sys.isapple() foo end@static foo <&&,||> bar も正当な構文です。

バージョニング

Base.VersionNumber ── 型

VersionNumber

セマンティックバージョニングの仕様に従うバージョン番号を表す型です。メジャー番号・マイナー番号・パッチ番号を表す数値、およびそれに続くリリース前状態やビルド番号を表す英数字からなります。@v_str を参照してください。

julia> VersionNumber("1.2.3")
v"1.2.3"

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

[email protected]_str ── マクロ

@v_str

文字列をパースして VersionNumber を構築する文字列マクロです。

julia> v"1.2.3"
v"1.2.3"

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

エラー

Base.error ── 関数

error(message::AbstractString)

与えられたメッセージを持った ErrorException を送出します。

error(msg...)

与えられたメッセージを持った ErrorException を送出します。

Core.throw ── 関数

throw(e)

オブジェクト e を例外として送出します。

Base.rethrow ── 関数

rethrow()

catch ブロックから現在処理しているのと同じ例外を送出します。

情報

もう一つの rethrow(e) という形を使うと、代わりの例外オブジェクト e を現在のバックトレースに結び付けることができます。しかしエラーのタイミングにおけるプログラムの状態が不正確になるので、throw(e) として新しい例外を送出することが推奨されます。catch_stack で説明されるように、Julia 1.1 以降で throw(e) を使うと最初の例外が例外スタックに保存されます。

Base.backtrace ── 関数

backtrace()

現在のプログラム点におけるバックトレースオブジェクトを取得します。

Base.catch_backtrace ── 関数

catch_backtrace()

現在処理中の例外のバックトレースを取得します。catch ブロックでのみ利用できます。

Base.catch_stack ── 関数

catch_stack(task=current_task(); [inclue_bt=true])

現在処理中の例外スタックを取得します。ネストされた catch ブロックでは現在の例外が複数存在する場合がありますが、そのときは最も最近に発生した例外がスタックの最後に積まれます。スタックは基本的に (exception,backtrace) の組のベクトルとして返されますが、include_btfalse にすると例外だけのベクトルとなります。

明示的に task を渡すと任意のタスクの例外スタックを返します。これは捕捉されない例外によって終了したタスクを調査するときに有用です。

Julia 1.1

この関数は Julia 1.1 で追加された実験的な関数であり、おそらく将来のリリースで名前が変わります (参照: https://github.com/JuliaLang/julia/pull/29901)。

[email protected] ── マクロ

@assert cond [text]

condfalse なら AssertionError を送出します。アサートを書くときに推奨される構文です。省略可能なメッセージ text を渡すと、アサートが失敗したときにそれが表示されます。

注意

アサートは最適化レベルによって無効化される可能性があります。そのためアサートはデバッグツールとしてのみ使われるべきであり、認証 (パスワードの確認など) に使うべきではありません。また関数が正しく動作するために必要な副作用を持つ式をアサートの中に入れるのも厳禁です。

julia> @assert iseven(3) "3 is an odd number!"
ERROR: AssertionError: 3 is an odd number!

julia> @assert isodd(3) "What even are numbers?"

Base.Experimental.register_error_hint ── 関数

Experimental.register_error_hint(handler, exceptiontype)

エラーの対処方法をユーザーに示す “ヒント関数” として handler(io, exception) を登録します。handlerexception を調べてヒントを出すべき条件が成り立っているかどうかを判定し、もし成り立っているなら io にヒントを出力します。パッケージは __init__ 関数の中で register_error_hint を呼び出すべきです。

特定の例外型に対応する handler は追加の引数を受け付ける必要があります:

  • MethodError: メソッドに渡された位置引数の型とキーワード引数を受け取る handler(io, exc::MethodError, argtypes, kwargs) を提供する。

ヒントを発するときは通常、出力を \n から始めるべきです。

独自の例外型でヒントをサポートするには、Experimental.show_error_hints をその型に対する showerror メソッドで呼んでください。

julia> module Hinter
       
       only_int(x::Int)      = 1
       any_number(x::Number) = 2
       
       function __init__()
           Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
               if exc.f == only_int
                    # 色は機能の存在を示すためにあるので、付けなくても構わない。
                    print(io, "\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)
Did you mean to call `any_number`?
Closest candidates are:
    ...
Julia 1.5

エラーに対するヒントのカスタマイズは Julia 1.5 以降で利用できます。

注意

このインターフェースは実験的であり、予告なく変更または削除される可能性があります。変更が起こっても大丈夫なように、ヒント関数の登録は if isdefined(Base.Experimental, :register_error_hint) ... end というブロックで行うことを推奨します。

Base.Experimental.show_error_hints ── 関数

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

特定の例外型 typeof(ex) に対して Experimental.register_error_hint で登録されたハンドラを全て起動します。argstypeof(ex) 型のハンドラが受け取る全ての引数を持つ必要があります。

Julia 1.5

エラーに対するヒントのカスタマイズは Julia 1.5 以降で利用できます。

注意

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

Core.ArgumentError ── 型

ArgumentError(msg)

関数の呼び出しに渡されたパラメータが正当なシグネチャのどれとも適合しないことを表すエラーの型です。引数 msg は状況を説明するエラー文字列です。

Core.AssertionError ── 型

AssertionError([msg])

アサートされた条件が true にならなかったことを表すエラーの型です。省略可能な引数 msg は状況を説明するエラー文字列です。

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

通常 AssertionError@assert から送出されます。

Core.BoundsError ── 型

BoundsError([a],[i])

配列 a に対する添え字アクセス演算が、境界外の要素を指す添え字 i に対するアクセスを試みたことを表すエラーの型です。

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: attempt to access 7-element Array{Float64,1} at index [8]
Stacktrace:
 [1] getindex(::Array{Float64,1}, ::Int64) at ./array.jl:660
 [2] top-level scope

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

julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Array{Float64,2} at index [2, 4]
Stacktrace:
 [1] getindex(::Array{Float64,2}, ::Int64, ::Int64) at ./array.jl:661
 [2] top-level scope

julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Array{Float64,2} at index [9]
Stacktrace:
 [1] getindex(::Array{Float64,2}, ::Int64) at ./array.jl:660
 [2] top-level scope

Base.CompositeException ── 型

CompositeException

Task が送出した複数の例外をまとめたベクトルをラップしたエラーの型です。Task はチャンネル越しのリモートワーカー、ローカルで非同期な IO 書き込みの実行、あるいは pmap で作成したリモートワーカーなどによって生成されます。例えばいくつかのタスクを実行しているワーカーのグループで複数のワーカーが失敗すると、例外が発生した場所と理由を示す情報を失敗した各ワーカーから取得してまとめた CompositeException が発生します。

Base.DimensionMismatch ── 型

DimensionMismatch([msg])

呼び出されたオブジェクトが正しい次元を持たないことを表すエラーの型です。省略可能な引数 msg は状況を説明するエラー文字列です。

Core.DivideError ── 型

DivideError()

除数が 0 の除算が行われたことを表すエラーの型です。

julia> 2/0
Inf

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

Core.DomainError ── 型

DomainError(val)
DomainError(val, msg)

関数またはコンストラクタに対する引数 val が正しい範囲から外れていることを表すエラーの型です。

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
[...]

Base.EOFError ── 型

EOFError()

ファイルまたはストリームから読み込めるデータがこれ以上存在しないことを表すエラーの型です。

Core.ErrorException ── 型

ErrorException(msg)

汎用的なエラーを表す型です。msg フィールドのエラーメッセージがエラーの詳細を提供します。

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

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

Core.InexactError ── 型

InexactError(name::Symbol, T, val)

関数 name のメソッドにおいて、val を正確に T 型へ変換できなかったことを表すエラーの型です。

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

Core.InterruptException ── 型

InterruptException()

ターミナルからの割り込み (CTRL+C) によってプロセスが停止したことを表すエラーの型です。

-i オプション (対話モード) を付けずに開始した Julia スクリプトは InterruptException を送出しないのがデフォルトであることに注意してください。スクリプトで Base.exit_on_sigint(false) を呼び出せば REPL での振る舞いを復元できます。また Julia スクリプトを次のコマンドで起動する方法もあります:

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

こうすれば実行中のCTRL+C によって InterruptException を送出されるようになります。

Base.KeyError ── 型

KeyError(key)

AbstractDict (Dict) または Set に似たオブジェクトへの添え字アクセス演算が、存在しない要素に対するアクセスまたは削除を試みたことを表すエラーの型です。

Core.LoadError ── 型

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

ファイルを include, require, using している間に起こったエラーを表す型です。起こったエラーは error フィールドから確認できます。

Core.MethodError ── 型

MethodError(f, args)

指定された総称関数に要求された型シグネチャを持つメソッドが存在しないこと、あるいは最も特定的なメソッドが一意でないことを表すエラーの型です。

Base.MissingException ── 型

MissingException(msg)

missing がサポートされていない箇所で使われたことを表すエラーの型です。msg フィールドのエラーメッセージがエラーの詳細を提供します。

Core.OutOfMemoryError ── 型

OutOfMemoryError()

操作がシステムまたはガベージコレクタが正しく処理できないほど多くのメモリがアロケートしたことを表すエラーの型です。

Core.ReadOnlyMemoryError ── 型

ReadOnlyMemoryError()

操作が読み込み専用のメモリに書き込もうとしたことを表すエラーの型です。

Core.OverflowError ── 型

OverflowError(msg)

式の評価結果が大きすぎるためにラップアラウンドが起こることを表すエラーの型です。

Base.ProcessFailedException ── 型

ProcessFailedException

プロセスが問題のある終了コードを持つことを表すエラーの型です。コマンドまたはパイプラインの実行では、ゼロでない終了コードが返ったとき (つまり起動されたプロセスが失敗したとき) にこの例外が送出されます。

Core.StackOverflowError ── 型

StackOverflowError()

要求された関数の呼び出しによってコールスタックのサイズが上限を上回ることを表すエラーの型です。よくある原因は無限に続く再帰呼び出しです。

Base.SystemError ── 型

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

失敗したシステムコールとそのエラーコード (グローバル変数 errno) の値を表すエラーの型です。

Core.TypeError ── 型

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

型のアサートが失敗したこと、もしくは組み込み命令関数を間違った引数型で呼び出したことを表すエラーの型です。

Core.UndefKeywordError ── 型

UndefKeywordError(var::Symbol)

必要なキーワード引数 var が関数呼び出しで割り当てられていないことを表すエラーの型です。

julia> function my_func(;my_arg)
           return my_arg + 1
       end
my_func (generic function with 1 method)

julia> my_func()
ERROR: UndefKeywordError: keyword argument my_arg not assigned
Stacktrace:
 [1] my_func() at ./REPL[1]:2
 [2] top-level scope at REPL[2]:1

Core.UndefRefError ── 型

UndefRefError()

要求された要素またはフィールドが指定されたオブジェクトに定義されていないことを表すエラーの型です。

julia> struct MyType
           a::Vector{Int}
           MyType() = new()
       end

julia> A = MyType()
MyType(#undef)

julia> A.a
ERROR: UndefRefError: access to undefined reference
Stacktrace:
[...]

Core.UndefVarError ── 型

UndefVarError(var::Symbol)

シンボルが現在のスコープで定義されていないことを表すエラーの型です。

julia> a
ERROR: UndefVarError: a not defined

julia> a = 1;

julia> a
1

Base.StringIndexError ── 型

StringIndexError(str, i)

str の位置 i に対するアクセスが失敗したことを表すエラーの型です。

Core.InitError ── 型

InitError(mod::Symbol, error)

モジュールの __init__ 関数を実行しているときにエラーが起こったことを表すエラーの型です。発生した実際のエラーは error フィールドで確認できます。

Base.retry ── 関数

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

関数 f を呼び出す無名関数を返します。返り値の無名関数を通した f の実行中に例外が発生すると、delays で指定される秒数だけ待ってから f が繰り返し (最大 length(delays) 回) 呼び出されます。ただし例外が起きるたびに check 関数が現在状態と例外を引数として呼び出され、そこで false を返すと反復がそこで終了します (このとき例外は retry を呼び出した側に伝わります)。check 関数が (state, true) のタプルを返すと、state が次の check の呼び出しの第一引数 (現在状態) となります2

Julia 1.2

Julia 1.2 以前では f::Function というシグネチャだけが利用できます。

retry(f, delays=fill(5.0, 3))
retry(f, delays=rand(5:10, 2))
retry(f, delays=Base.ExponentialBackOff(n=3, first_delay=5, max_delay=1000))
retry(http_get, check=(s,e)->e.status == "503")(url)
retry(read, check=(s,e)->isa(e, IOError))(io, 128; all=false)

Base.ExponentialBackOff ── 型

ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)

Float64 を返す長さ n の反復子であって、各要素が factor * (1 ± jitter) という区間に含まれる値を指数として指数的に増えるようなものを表します。最初の要素は first_delay であり、全ての要素は最大でも max_delay となるよう調整されます。

イベント

Base.Timer ── メソッド

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

タイマーを作成します。このタイマーは自身に対して wait するタスクを起動してから callback を呼び出す処理を定期的に行います。

タイマーに対して wait するタスクは最初 delay 秒だけ待たされてから起動され、その後は interval 秒ごとに起動されます。interval0 だと、タイマーは一度だけタスクを起動します。関数 callback はタイマーを唯一の引数として呼び出されます。タイマーを close で閉じると、そのタイマーを wait するタスクはエラーによって起動されます。タイマーが生きているかどうかは isopen で確認してください。

次の例では最初の 1 は二秒後に表示され、その次の 23 は素早く表示されます。

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

Base.Timer ── 型

Timer(delay; interval = 0)

タイマーを作成します。このタイマーは自身に対して wait するタスクを起動する処理を定期的に行います。

タイマーに対して wait するタスクは最初 delay 秒だけ待たされてから起動され、その後は interval 秒ごとに起動されます。interval0 だと、タイマーは一度だけタスクを起動します。タイマーを close で閉じると、そのタイマーを wait するタスクはエラーによって起動されます。タイマーが生きているかは isopen で確認してください。

Base.AsyncCondition ── 型

AsyncCondition()

非同期条件を作成します。このオブジェクトに対して wait するタスクは C コードが uv_async_send を呼んだときに通知を受けます。このオブジェクトを close すると、それに対して wait しているタスクはエラーによって起動されます。オブジェクトが生きているかは isopen で確認してください。

Base.AsyncCondition ── メソッド

AsyncCondition(callback::Function)

指定した callback 関数を呼び出す非同期条件を作成します。callback は非同期条件を唯一の引数に受け取ります。

リフレクション

Base.nameof ── メソッド

nameof(m::Module) -> Symbol

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

julia> nameof(Base.Broadcast)
:Broadcast

Base.parentmodule ── 関数

parentmodule(m::Module) -> Module

Module を持つモジュールを取得します。Main の親は Main です。

julia> parentmodule(Main)
Main

julia> parentmodule(Base.Broadcast)
Base
parentmodule(t::DataType) -> Module

DataType の定義を持つモジュールを取得します。tUnionAll でラップされていても構いません。

julia> module Foo
           struct Int end
       end
Foo

julia> parentmodule(Int)
Core

julia> parentmodule(Foo.Int)
Foo
parentmodule(f::Function) -> Module

総称関数の (最初の) 定義を持つモジュールを取得します。

parentmodule(f::Function, types) -> Module

総称関数の指定されたメソッドの定義を持つモジュールを取得します。

Base.pathof ── メソッド

pathof(m::Module)

モジュール mimport するときに使われたファイル m.jl のパスを取得します。m がパッケージからインポートされたのでなければ nothing を返します。

パスのディレクトリの部分は dirname で、ファイルの部分は basename で取得できます。

Base.moduleroot ── 関数

moduleroot(m::Module) -> Module

指定されたモジュールのルートモジュールを検索します。m のルートモジュールとは、m の親モジュールの中で最初に現れる登録されたルートモジュール、もしくは親が自身と等しいモジュールのことです。

[email protected]__MODULE__ ── マクロ

@__MODULE__ -> Module

トップレベルの評価式 (現在読み込んで実行しているコード) を持つ Module を取得します。

Base.fullname ── 関数

fullname(m::Module)

完全に修飾されたモジュールの名前をシンボルのタプルとして取得します。

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

julia> fullname(Main)
(:Main,)

Base.names ── 関数

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

モジュール x がエクスポートする名前からなる配列を返します。非推奨の名前は除外されます。alltrue なら、モジュールで定義されるエクスポートされない名前・非推奨の名前・コンパイラによって生成される名前が返り値の配列に追加されます。importedtrue なら、他のモジュールからインポートされた名前も明示的に追加されます。

Main で定義される名前は特別に全てエクスポートされるものとみなされます。普通 Main からは名前を明示的にエクスポートしないためです。

Core.nfields ── 関数

nfields(x) -> Int

オブジェクト x が持つフィールドの個数を取得します。

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

この例で aRational であり、二つのフィールドを持ちます。bisbitstype なプリミティブ型 Int であり、フィールドを一つも持ちません。exErrorException なので、フィールドを一つ持ちます。

Base.isconst ── 関数

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

グローバル変数 s がモジュール mconst と宣言されたかどうかを判定します。

Base.nameof ── メソッド

nameof(f::Function) -> Symbol

総称関数 f の名前をシンボルとして取得します。無名関数に対してはコンパイラが生成した名前が返り、明示的に宣言された Function の部分型に対しては関数の型の名前が返ります。

Base.functionloc ── メソッド

functionloc(f::Function, types)

types を引数に受け取る総称関数 f のメソッドが定義された位置を示すタプル (filename,line) を返します。

Base.functionloc ── メソッド

functionloc(m::Method)

メソッド m が定義された位置を示すタプル (filename,line) を返します。

内部操作

Base.GC.gc ── 関数

GC.gc([full=true])

ガベージコレクションを実行します。引数 full はガベージコレクションの種類を指定します。デフォルトのフルコレクションは全てのオブジェクトをスイープするので、次の GC スキャンが非常に遅くなります。これに対して fullfalse にした場合のインクリメンタルなコレクションでは、いわゆる “若い” オブジェクトだけがスイープされます。

注意

使い過ぎると性能が低下します。

Base.GC.enable ── 関数

GC.enable(on::Bool)

ガベージコレクションの有効/無効を切り替えます。真偽値の引数 ontrue のとき有効となり、false のとき無効となります。以前の GC 状態を返します。

注意

ガベージコレクションを無効化するとメモリ使用量が際限なく増えるので、無効化するときは注意が必要です。

[email protected] ── マクロ

[email protected] x1 x2 ... xn expr

オブジェクト x1, x2, ... に使用中の印を付けた状態で式 expr を実行します。このマクロが必要になるのは、xi が持つメモリやリソースを expr 中の unsafe なコードが暗黙に使用するときだけです。

x が持つメモリやリソースの暗黙な使用とは、論理的には x が保有するデータをコンパイラから見えない形で使用することを言います。暗黙な使用の例を示します:

  • Ptr を通して x のメモリに直接アクセスする。
  • x を指すポインタを ccall に渡す。
  • ファイナライザで掃除されるはずの x のリソースを使う。

@preserve はオブジェクトの寿命を少しだけ伸ばすだけなので、通常は性能に影響しないはずです。@preserve の実装は動的にアロケートされたオブジェクトをガベージコレクションから保護するといった処理を行います。

unsafe_load でポインタを読み込むとき、そのポインタが指すオブジェクトが暗黙に使用されます。例えば次のコードでは xunsafe_load(p) によって暗黙に使用されています:

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

ccall にポインタを渡すときも、そのポインタが指すオブジェクトが暗黙に使用されるので保護が必要です (ただし普通は x を直接 ccall に渡すべきであり、このときは明示的な利用となることに注意してください):

julia> let
           x = "Hello"
           p = pointer(x)
           Int(GC.@preserve x @ccall strlen(p::Cstring)::Csize_t)
           # 推奨される書き方
           Int(@ccall strlen(x::Cstring)::Csize_t)
        end
5

Base.GC.safepoint ── 関数

GC.safepoint()

ガベージコレクションの実行を許可する目印をプログラムに挿入します。これはマルチスレッドのプログラムでいくつかのスレッドがメモリをアロケートしており (つまり GC の実行が必要になる可能性があり)、他のスレッドが単純な処理 (アロケート・タスク切り替え・IO を行わない処理) をしているという稀な状況で利用できます。この関数をアロケートを行わないスレッドから定期的に呼び出せば、ガベージコレクションを実行させることができます。

Julia 1.4

この関数は Julia 1.4 以降でサポートされます。

Base.Meta.lower ── 関数

lower(m, x)

x をモジュール m で実行するときの低水準形式 (lowered form) を返します。code_lowered も参照してください。

[email protected] ── マクロ

@lower [m] x

モジュール m における式 x の低水準形式を返します。m はデフォルトでマクロを呼び出したモジュールとなります。lower も参照してください。

Base.Meta.parse ── メソッド

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

式を表す文字列をパースして、式 (eval に渡して実行できるオブジェクト) と読み込んだ文字列の長さを返します。start はパースを開始する文字の添え字です。greedytrue (デフォルト値) だと、parse はできるだけ多くの入力を読もうとします。これに対して greedyfalse だと、parse は正当な式を一つパースした時点で処理を止めます。不完全であるものの構文的には正当な文に対しては Expr(:incomplete, "(error message)") が返ります。raisetrue だと、不完全な式以外の構文エラーはエラーを送出します。これに対して raisefalse だと、構文エラーのとき「評価するとエラーが起こる式」が返るようになります。depwarnfalse だと、非推奨の警告が出なくなります。

julia> Meta.parse("x = 3, y = 5", 7)
(:(y = 5), 13)

julia> Meta.parse("x = 3, y = 5", 5)
(:((3, y) = 5), 13)

Base.Meta.parse ── メソッド

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

式を表す文字列を貪欲にパースして、単一の式を返します。最初の式の後ろに余計な文字があった場合にはエラーを送出します。raisetrue (デフォルト値) だと、構文エラーはエラーを送出します。これに対して raisefalse だと、構文エラーのとき「評価するとエラーが起こる式」が返るようになります。depwarnfalse だと、非推奨の警告が出なくなります。

julia> Meta.parse("x = 3")
:(x = 3)

julia> Meta.parse("x = ")
:($(Expr(:incomplete, "incomplete: premature end of input")))

julia> Meta.parse("1.0.2")
ERROR: Base.Meta.ParseError("invalid numeric constant \"1.0.\"")
Stacktrace:
[...]

julia> Meta.parse("1.0.2"; raise = false)
:($(Expr(:error, "invalid numeric constant \"1.0.\"")))

Base.Meta.ParseError ── 型

ParseError(msg)

parse 関数に渡された式が正当な Julia の式として解釈できないことを表すエラーの型です。

Core.QuoteNode ── 型

QuoteNode

補間をサポートしないクオートされたコードを表します。詳細はマニュアルの QuoteNode に関する節を参照してください。

Base.macroexpand ── 関数

macroexpand(m::Module, x; recursive=true)

モジュール m で式 x を実行するとして、x に含まれるマクロを全て取り去った (展開した) 等価な式を返します。キーワード引数 recursive はネストされたマクロを展開するかどうかを制御します。recursive の使用例を示します:

julia> module M
           macro m1()
               42
           end
           macro m2()
               :(@m1())
           end
       end
M

julia> macroexpand(M, :(@m2()), recursive=true)
42

julia> macroexpand(M, :(@m2()), recursive=false)
:(#= REPL[16]:6 =# M.@m1)

[email protected] ── マクロ

@macroexpand

x に含まれるマクロを全て取り去った (展開した) 等価な式を返します。

@macroexpandmacroexpand には次の違いがあります:

  • macroexpand はキーワード引数 recursive を受け取りますが、@macroexpand は常に再帰的です。再帰的でないマクロは @macroexpand1 です。

  • macroexpand は引数に module を受け取りますが、@macroexpand は呼び出したモジュールで式を展開します。

この違いが分かる例を示します:

julia> module M
           macro m()
               1
           end
           function f()
               (@macroexpand(@m),
                macroexpand(M, :(@m)),
                macroexpand(Main, :(@m))
               )
           end
       end
M

julia> macro m()
           2
       end
@m (macro with 1 method)

julia> M.f()
(1, 1, 2)

@macroexpand では式の展開が @macroexpand が書かれたモジュール (上の例では M) で起きますが、macroexpand では式を展開するモジュールが第一引数で指定されます。

[email protected] ── マクロ

@macroexpand1

再帰的でないバージョンの @macroexpand です。

Base.code_lowered ── 関数

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

与えられた総称関数と型シグネチャに適合するメソッドの低水準形式からなる配列を返します。

generatedfalse なら、返り値の配列に含まれる CodeInfo インスタンスはフォールバック実装に対応し3、フォールバック実装が存在しなければエラーが送出されます。generatedtrue なら、CodeInfo インスタンスは被生成関数を展開して得られるメソッドに対応します。

キーワード引数 debuginfo は出力に表示されるコードのメタデータの量を制御します。debuginfo に使える値は :source:none です。

generatedtrue で対応するメソッドのいずれかが @generated メソッドのときは、types が葉型でないとエラーが発生することに注意してください。

Base.code_typed ── 関数

code_typed(f, types; optimize=true, debuginfo=:default)

与えられた総称関数と型シグネチャに適合するメソッドを表す、型が推論された低水準形式 (IR) の配列を返します。キーワード引数 optimize はインライン化などの追加の最適化を適用するかどうかを制御します。キーワード引数 debuginfo は出力に表示されるコードのメタデータの量を制御します。debuginfo に使える値は :source:none です。

Base.precompile ── 関数

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

タプル args が表す引数 (の型) に対する関数 f のメソッドをコンパイルします。実行はしません。

メタ操作

Base.Meta.quot ── 関数

Meta.quot(ex)::Expr

ex をクオートして、headquote を持つ式を生成します。これは例えば AST に含まれる Expr 型のオブジェクトを表すのに利用できます。マニュアルの QuoteNode の節も参照してください。

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

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

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

Base.Meta.isexpr ── 関数

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

exhead が引数 head に等しいこと、そして exn 個の引数を持つことを確認します。

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

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

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

julia> Meta.isexpr(ex, [:block, :call]) # head は :block または :call か?
true

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

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

Base.Meta.show_sexpr ── 関数

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

ex を lisp の S-式のように表示します。

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

  1. 訳注: 「プロパティ」と「フィールド名」の違いについては What's the difference between fields and properties? に説明がある。[return]

  2. 訳注: 英語版の説明に check 関数の説明を追加した。[return]

  3. 訳注: ここでは随時被生成関数の話をしている。[return]

日本語 Julia 書籍 (Amazon アソシエイト)
1 から始める Julia プログラミング
Julia プログラミングクックブック―言語仕様からデータ分析、機械学習、数値計算まで
スタンフォード ベクトル・行列からはじめる最適化数学