基本的な関数

exit(code=0)

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

atexit(f)

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

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

isinteractive() -> Bool

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

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

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

キーワード引数

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

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

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

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

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

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

Base.compilecache(module::PkgId)

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

__precompile__(isprecompilable::Bool)

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

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

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

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

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

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

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

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

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

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

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

include_dependency(path::AbstractString)

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

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

which(f, types)

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

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

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

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

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

@show

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

ans

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

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

import

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

using

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

baremodule

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

function

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

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

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

add(a, b) = a + b

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

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 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 が最初に偶数となったときに return が test1 関数を終了させるので、test1([5,6,7]) は 12 を返します。

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

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

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...end はコードのブロックを表します。

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

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

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 var1 = value1, var2, var3 = value3
    code
end

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

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

for

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

例

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

while

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

例

julia> i = 1
1

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

break

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

例

julia> i = 0
0

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

continue

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

例

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

try/catch

try/catch を使うと、throw が発生させるエラー (例外) を捕捉し、プログラムの実行を継続させることができます。例えば次のコードはファイルへ書き込みを行いますが、ファイルが書き込めないときに実行を終了せず、ユーザーに警告を表示します:

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "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

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

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 はブロックに含まれる複数の式を表すオブジェクトを Expr を使うことなく作成します。例を示します:

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

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

local

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

例

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

julia> foo(10)
0

global

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

例

julia> z = 3
3

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

julia> foo()
6

julia> z
6

const

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

const x = 5

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

const y, z = 7, 11

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

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

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

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

abstract type

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

abstract type Number end
abstract type Real <: Number end

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

primitive type

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

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

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

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

例

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

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

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

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

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

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

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

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

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

julia> a, b
(1, 2)

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

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

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

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

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

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

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

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

julia> filter!(x -> x > 1, a) # インプレースなので 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 はトップレベルモジュールであり、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 は言語に「組み込み (built-in)」とみなされる識別子を全て含むモジュールです。つまり Core に含まれる識別子はコア言語の一部であり、ライブラリの一部ではありません。こういった識別子の定義が存在しないと何もできないので、全てのモジュールは暗黙に using Core を実行するものとされます。

Base

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

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

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

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

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

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

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

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

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

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

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

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

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

例

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

julia> a == b
true

julia> a === b
false

julia> a === a
true

isa(x, type) -> Bool

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

例

julia> isa(1, Int)
true

julia> isa(1, Matrix)
false

julia> isa(1, Char)
false

julia> isa(1, Number)
true

julia> 1 isa Number
true

isequal(x, y)

基本的に == と同様ですが、浮動小数点数と欠損値の扱いが異なります。isequal は NaN と NaN を等しいとみなし、-0.0 と 0.0 を異なるとみなし、missing と missing を等しいとみなします。返り値は必ず 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)} 型であり、特殊化されたメソッドを実装するときに利用できます。

isless(x, y)

x が y より小さいかどうかを判定します。比較には固定された全順序が使われます。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 は順序で最後に位置付けられます。

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

実装

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

例

julia> isless(1, 3)
true

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

ifelse(condition::Bool, x, y)

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

例

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

typeassert(x, type)

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

例

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

typeof(x)

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

例

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

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

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

tuple(xs...)

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

例

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

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

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

例

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

objectid(x)

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

hash(x[, h::UInt])

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

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

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

finalize(x)

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

copy(x)

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

deepcopy(x)

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

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

getproperty(value, name::Symbol)

構文 a.b は getproperty(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

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

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

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

propertynames と getproperty も参照してください。

propertynames(x, private=false)

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

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

hasproperty(x, s::Symbol)

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

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

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

例

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

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1

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

複合型の値 value のフィールド name に x を代入します。value は可変である必要があり、x は fieldtype(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

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

@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

convert(T, x)

x を T 型の値に変換します。

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

例

julia> convert(Int, 3.0)
3

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

T が AbstractFloat 型もしくは 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

promote(xs...)

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

例

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

oftype(x, y)

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

例

julia> x = 4;

julia> y = 3.;

julia> oftype(x, y)
3

julia> oftype(y, x)
4.0

widen(x)

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

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

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

例

julia> widen(Int32)
Int64

julia> widen(1.5f0)
1.5

identity(x)

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

例

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

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

T の上位型を返します。

例

julia> supertype(Int32)
Signed

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

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

<:(T1, T2)

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

例

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

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

>:(T1, T2)

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

typejoin(T, S)

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

typeintersect(T, S)

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

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

promote_rule(type1, type2)

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

isdispatchtuple(T)

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

ismutable(v) -> Bool

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

例

julia> ismutable(1)
false

julia> ismutable([1,2])
true

isimmutable(v) -> Bool

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

例

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false

isabstracttype(T)

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

例

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false

isprimitivetype(T) -> Bool

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

Base.issingletontype(T)

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

isstructtype(T) -> Bool

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

nameof(t::DataType) -> Symbol

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

例

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

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

fieldnames(x::DataType)

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

例

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

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

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

例

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den

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

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

sizeof(T::DataType)
sizeof(obj)

型 T に正準バイナリ表現が存在するなら、そのサイズを返します (単位はバイト)。T が DataType 型の値でないなら、オブジェクト 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:
[...]

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

isbits(x)

x が isbitstype な型のインスタンスなら true を返します。

isbitstype(T)

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

例

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false

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

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

例

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

julia> fieldtype(Foo, :x)
Int64

julia> fieldtype(Foo, 2)
String

fieldtypes(T::Type)

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

例

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

julia> fieldtypes(Foo)
(Int64, String)

fieldcount(t::Type)

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

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(dt::DataType) -> Int

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

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

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

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

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

typemin(T)

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

例

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

typemax(T)

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

例

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

floatmin(T=Float64)

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

例

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

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308

floatmax(T=Float64)

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

例

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

maxintfloat(T=Float64)

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

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

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

maxintfloat(T, S)

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

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

浮動小数点数型 T の計算機イプシロン (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

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\) に対して次の不等式が成り立ちます:

例

julia> eps(1.0)
2.220446049250313e-16

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

julia> eps(2.0)
4.440892098500626e-16

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

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

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

instances(T::Type)

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

例

julia> @enum Color red blue green

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

Any::DataType

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

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

例

julia> isa(nothing, Union{})
false

UnionAll

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

例

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType

Tuple{Types...}

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

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

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

NamedTuple

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

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

@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,)

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

Val(c)

実行時データを持たない値 Val{c}() を返します。c は isbits な値である必要があります。この種の型は値 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"

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