Essentials

Introduction

Julia Base contains a range of functions and macros appropriate for performing scientific and numerical computing, but is also as broad as those of many general purpose programming languages. Additional functionality is available from a growing collection of available packages. Functions are grouped by topic below.

いくつかの一般的なメモ:

  • モジュールの関数を使用するには、import Moduleを使ってモジュールをインポートし、Module.fn(x)を使って関数を利用します。
  • 代わりに、using ModuleはすべてのエクスポートされたModule関数を現在の名前空間にインポートします。
  • 慣例として、感嘆符(!)で終わる関数名はその引数を変更します。一部の関数には、変更を行うバージョン(例:sort!)と変更を行わないバージョン(sort)の両方があります。

Base と標準ライブラリの動作は、SemVer に定義されているように、文書化されている場合に限り安定しています。つまり、Julia documentation に含まれ、非安定としてマークされていない必要があります。詳細については、API FAQ を参照してください。

Getting Around

Base.exitFunction
exit(code=0)

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

source
Base.atexitFunction
atexit(f)

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

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

Julia 1.9

一引数形式は Julia 1.9 を必要とします。

終了フックは exit(n) を呼び出すことが許可されており、その場合、Julia は終了コード n で終了します(元の終了コードではなく)。複数の終了フックが exit(n) を呼び出す場合、Julia は exit(n) を呼び出した最後の終了フックに対応する終了コードで終了します。(終了フックは LIFO 順序で呼び出されるため、「最後に呼び出された」は「最初に登録された」と同等です。)

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

source
Base.isinteractiveFunction
isinteractive() -> Bool

Juliaがインタラクティブセッションで実行されているかどうかを判断します。

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

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

キーワード引数

  • exclude: トラバーサルから除外するオブジェクトの型を指定します。
  • chargeall: 通常は除外されるフィールドであっても、すべてのフィールドのサイズを常に計上するオブジェクトの型を指定します。

詳細は sizeof を参照してください。

julia> Base.summarysize(1.0)
8

julia> Base.summarysize(Ref(rand(100)))
848

julia> sizeof(Ref(rand(100)))
8
source
Base.__precompile__Function
__precompile__(isprecompilable::Bool)

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

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

モジュール m のグローバルスコープで入力ソースファイルの内容を評価します。 baremodule で定義されたモジュールを除いて、すべてのモジュールは m 引数を省略した独自の include 定義を持ち、そのモジュール内でファイルを評価します。入力ファイルの最後に評価された式の結果を返します。インクルード中は、タスクローカルのインクルードパスがファイルを含むディレクトリに設定されます。ネストされた include 呼び出しは、そのパスに対して相対的に検索されます。この関数は通常、インタラクティブにソースをロードするため、または複数のソースファイルに分割されたパッケージ内のファイルを結合するために使用されます。

オプションの最初の引数 mapexpr は、評価される前にインクルードされたコードを変換するために使用できます:path 内の各解析された式 expr に対して、include 関数は実際に mapexpr(expr) を評価します。省略された場合、mapexpridentity にデフォルト設定されます。

Julia 1.5

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

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

入力ソースファイルの内容を、含まれているモジュールのグローバルスコープで評価します。baremoduleで定義されたモジュールを除いて、すべてのモジュールには独自のincludeの定義があり、そのモジュール内でファイルを評価します。入力ファイルの最後に評価された式の結果を返します。インクルード中は、タスクローカルのインクルードパスがファイルを含むディレクトリに設定されます。ネストされたincludeの呼び出しは、そのパスに対して相対的に検索されます。この関数は、通常、ソースをインタラクティブにロードするため、または複数のソースファイルに分割されたパッケージ内のファイルを結合するために使用されます。引数pathnormpathを使用して正規化され、..のような相対パスのトークンを解決し、/を適切なパスセパレーターに変換します。

オプションの最初の引数mapexprは、評価される前に含まれるコードを変換するために使用できます:path内の各解析された式exprに対して、include関数は実際にmapexpr(expr)を評価します。省略した場合、mapexpridentityにデフォルト設定されます。

別のモジュールにファイルを評価するには、Base.includeを使用してください。

Julia 1.5

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

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

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

オプションの最初の引数 mapexpr は、評価される前に含まれるコードを変換するために使用できます:code 内の各解析された式 expr に対して、include_string 関数は実際に mapexpr(expr) を評価します。省略した場合、mapexpridentity にデフォルト設定されます。

Julia 1.5

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

source
Base.include_dependencyFunction
include_dependency(path::AbstractString; track_content::Bool=true)

モジュール内で、path(相対または絶対)の指定されたファイル、ディレクトリ、またはシンボリックリンクがプリコンパイルの依存関係であることを宣言します。つまり、track_content=trueの場合、pathの内容が変更されるとモジュールは再コンパイルが必要になります(pathがディレクトリの場合、内容はjoin(readdir(path))に等しいです)。track_content=falseの場合、pathの修正時間mtimeが変更されると再コンパイルがトリガーされます。

これは、モジュールがincludeを介して使用されていないパスに依存している場合にのみ必要です。コンパイルの外では効果がありません。

Julia 1.11

キーワード引数track_contentは少なくともJulia 1.11が必要です。pathが読み取り可能でない場合はエラーがスローされます。

source
__init__Keyword
__init__

__init__() 関数は、モジュールがランタイムで初めて読み込まれた に即座に実行されます。これは、モジュール内の他のすべてのステートメントが実行された後に一度だけ呼び出されます。モジュールが完全にインポートされた後に呼び出されるため、サブモジュールの __init__ 関数が最初に実行されます。__init__ の典型的な使用例は、外部 C ライブラリのランタイム初期化関数を呼び出すことと、外部ライブラリによって返されるポインタを含むグローバル定数を初期化することです。詳細については、モジュールに関するマニュアルセクションを参照してください。

const foo_data_ptr = Ref{Ptr{Cvoid}}(0)
function __init__()
    ccall((:foo_init, :libfoo), Cvoid, ())
    foo_data_ptr[] = ccall((:foo_data, :libfoo), Ptr{Cvoid}, ())
    nothing
end
source
Base.whichMethod
which(f, types)

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

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

関連情報: parentmodule, @which, および @edit.

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

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

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

Julia 1.4

モジュールを指定するには少なくともJulia 1.4が必要です。

参照: which, @which および methodswith.

source
Base.@showMacro
@show exs...

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

関連情報: show, @info, println.

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

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

最後に計算された値を参照する変数で、インタラクティブプロンプトに自動的にインポートされます。

source
Base.MainInclude.errConstant
err

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

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

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

Julia 1.8

この関数は少なくとも Julia 1.8 が必要です。

source

Keywords

これはJuliaの予約語のリストです: baremodule, begin, break, catch, const, continue, do, else, elseif, end, export, false, finally, for, function, global, if, import, let, local, macro, module, quote, return, struct, true, try, using, while。これらのキーワードは変数名として使用することはできません。

次の二語のシーケンスは予約されています: abstract type, mutable struct, primitive type。ただし、次の名前の変数を作成することはできます: abstract, mutable, primitive および type

最終的に:where はパラメトリックメソッドおよび型定義を書くための中置演算子として解析されます; inisa は中置演算子として解析されます; public はトップレベルステートメントの開始時にキーワードとして解析されます; outerfor ループの反復仕様における変数のスコープを修正するために使用されるときにキーワードとして解析されます;そして asimport または using によってスコープに持ち込まれた識別子の名前を変更するためのキーワードとして使用されます。ただし、whereinisaouter および as という名前の変数の作成は許可されています。

moduleKeyword
module

moduleModule を宣言し、これは別のグローバル変数のワークスペースです。モジュール内では、他のモジュールからどの名前が見えるかを制御(インポートを通じて)し、あなたの名前のうちどれが公開されることを意図しているかを指定できます(exportpublic を通じて)。モジュールを使用すると、他の人のコードと一緒に使用される際に名前の衝突を心配することなく、トップレベルの定義を作成できます。詳細については、モジュールに関するマニュアルのセクションを参照してください。

module Foo
import Base.show
export MyType, foo

struct MyType
    x
end

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

export はモジュール内で使用され、Julia にどの名前をユーザーに利用可能にするかを指示します。例えば、export foo は名前 foo をモジュールを using したときに利用可能にします。詳細については、モジュールに関するマニュアルセクション を参照してください。

source
publicKeyword
public

public はモジュール内で使用され、Julia に対してそのモジュールのパブリック API の一部である名前を示します。例えば、public foo は名前 foo がパブリックであることを示しますが、モジュールを using したときに利用可能にするわけではありません。詳細については、モジュールに関するマニュアルのセクションを参照してください。

Julia 1.11

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

source
importKeyword
import

import Foo はモジュールまたはパッケージ Foo をロードします。インポートされた Foo モジュールからの名前にはドット構文を使用してアクセスできます(例:Foo.foo で名前 foo にアクセス)。詳細については、モジュールに関するマニュアルセクションを参照してください。

source
usingKeyword
using

using Foo はモジュールまたはパッケージ Foo をロードし、その export された名前を直接使用できるようにします。名前はドット構文(例:Foo.foo で名前 foo にアクセス)を介しても使用できます。これは、export されているかどうかに関係ありません。詳細については、モジュールに関するマニュアルセクション を参照してください。

Note

2つ以上のパッケージ/モジュールが同じ名前をエクスポートし、その名前が各パッケージで同じものを指さない場合、明示的な名前のリストなしに using を介してパッケージがロードされると、その名前を修飾なしで参照することはエラーになります。したがって、将来の依存関係やJuliaのバージョンとの互換性を考慮したコード、例えばリリースされたパッケージのコードは、各ロードされたパッケージから使用する名前をリストすることが推奨されます。例えば、using Foo: Foo, f のように、using Foo よりも明示的に指定することが望ましいです。

source
asKeyword
as

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

import LinearAlgebra as LA は、インポートされた LinearAlgebra 標準ライブラリを LA としてスコープに持ち込みます。

import LinearAlgebra: eigen as eig, cholesky as chol は、LinearAlgebra から eigen および cholesky メソッドをそれぞれ eig および chol としてスコープに持ち込みます。

as は、個々の識別子がスコープに持ち込まれる場合にのみ using と一緒に機能します。たとえば、using LinearAlgebra: eigen as eig または using LinearAlgebra: eigen as eig, cholesky as chol は機能しますが、using LinearAlgebra as LA は無効な構文です。なぜなら、LinearAlgebra からエクスポートされた すべての 名前を LA に変更することは意味がないからです。

source
baremoduleKeyword
baremodule

baremoduleは、using Baseevalおよびincludeのローカル定義を含まないモジュールを宣言します。それでもCoreはインポートします。言い換えれば、

module Mod

...

end

は次のように等価です。

baremodule Mod

using Base

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

...

end
source
functionKeyword
function

関数は function キーワードを使って定義されます:

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

または短縮形の表記:

add(a, b) = a + b

return キーワードの使い方は他の言語と全く同じですが、しばしば省略可能です。明示的な return 文がない関数は、関数本体の最後の式を返します。

source
macroKeyword
macro

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

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

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

julia> @sayhello "Charlie"
Hello, Charlie!

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

julia> @saylots "hey " "there " "friend"
Say: hey there friend
source
returnKeyword
return

return x は、囲まれた関数を早期に終了させ、与えられた値 x を呼び出し元に返します。値なしの returnreturn nothing と同等です(nothing を参照)。

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

一般に、関数本体内のどこにでも return 文を置くことができます。深くネストされたループや条件文の中でも可能ですが、do ブロックには注意が必要です。例えば:

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

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

最初の例では、return は偶数に出会った時点で test1 を終了させるため、test1([5,6,7])12 を返します。

2番目の例も同じように動作すると思うかもしれませんが、実際にはそこにある return内側 の関数(do ブロック内)からのみ抜け出し、map に値を返します。したがって、test2([5,6,7])[5,12,7] を返します。

トップレベルの式(すなわち、任意の関数の外)で使用されると、return は現在のトップレベルの式全体を早期に終了させます。

source
doKeyword
do

無名関数を作成し、それを関数呼び出しの最初の引数として渡します。例えば:

map(1:10) do x
    2x
end

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

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

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

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

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

通常、begin は必要ありません。なぜなら、functionlet のようなキーワードは、暗黙的にコードのブロックを開始するからです。詳細は ; を参照してください。

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

Julia 1.4

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

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

julia> A[begin, :]
2-element Array{Int64,1}:
 1
 2
source
endKeyword
end

end は、modulestructmutable structbeginletfor などの式のブロックの結論を示します。

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
source
letKeyword
let

let ブロックは新しいハードスコープを作成し、オプションで新しいローカルバインディングを導入します。

他のスコープ構造と同様に、let ブロックは新しく導入されたローカル変数がアクセス可能なコードのブロックを定義します。さらに、構文はカンマ区切りの代入と、let と同じ行にオプションで現れる変数名に特別な意味を持ちます。

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

この行で導入された変数は let ブロックにローカルであり、代入は順番に評価され、各右辺は左辺の名前を考慮せずにスコープ内で評価されます。したがって、let x = x のように書くことは理にかなっています。なぜなら、2つの x 変数は異なり、左辺が外部スコープの x をローカルにシャドウイングしているからです。これは、ローカルスコープに入るたびに新しいローカル変数が新たに作成されるため、特にクロージャを介してスコープを超えて生き残る変数の場合に有用なイディオムとなることがあります。上記の例の var2 のように、代入なしの let 変数は、まだ値にバインドされていない新しいローカル変数を宣言します。

対照的に、begin ブロックは複数の式をまとめますが、スコープを導入したり、特別な代入構文を持ったりはしません。

以下の関数では、単一の xmap によって3回反復的に更新されます。返されるクロージャはすべてその1つの x を最終値で参照します。

julia> function test_outer_x()
           x = 0
           map(1:3) do _
               x += 1
               return ()->x
           end
       end
test_outer_x (generic function with 1 method)

julia> [f() for f in test_outer_x()]
3-element Vector{Int64}:
 3
 3
 3

しかし、新しい ローカル変数を導入する let ブロックを追加すると、同じ名前を使用(シャドウ)することを選んでも、3つの異なる変数がキャプチャされることになります(各反復ごとに1つ)。

julia> function test_let_x()
           x = 0
           map(1:3) do _
               x += 1
               let x = x
                   return ()->x
               end
           end
       end
test_let_x (generic function with 1 method)

julia> [f() for f in test_let_x()]
3-element Vector{Int64}:
 1
 2
 3

新しいローカル変数を導入するすべてのスコープ構造は、繰り返し実行されるとこのように動作します。let の特徴的な機能は、同じ名前の外部変数をシャドウイングする新しい local を簡潔に宣言できることです。たとえば、do 関数の引数を直接使用することも、同様に3つの異なる変数をキャプチャします。

julia> function test_do_x()
           map(1:3) do x
               return ()->x
           end
       end
test_do_x (generic function with 1 method)

julia> [f() for f in test_do_x()]
3-element Vector{Int64}:
 1
 2
 3
source
ifKeyword
if/elseif/else

if/elseif/else は条件評価を行い、ブール式の値に応じてコードの一部を評価するかどうかを決定します。以下は if/elseif/else 条件構文の構造です:

if x < y
    println("x は y より小さい")
elseif x > y
    println("x は y より大きい")
else
    println("x は y と等しい")
end

条件式 x < y が真であれば、対応するブロックが評価されます。そうでなければ、条件式 x > y が評価され、もしそれが真であれば、対応するブロックが評価されます。どちらの式も真でない場合は、else ブロックが評価されます。elseifelse ブロックはオプションであり、必要に応じて任意の数の elseif ブロックを使用できます。

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

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

for ループは、値のシーケンスを反復処理しながら、ステートメントのブロックを繰り返し評価します。

反復変数は常に新しい変数であり、たとえ同じ名前の変数が外側のスコープに存在していてもそうです。反復のために既存のローカル変数を再利用するには、outer を使用してください。

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

while ループは条件式を繰り返し評価し、式が真である限りループの本体を評価し続けます。最初に while ループに到達したときに条件式が偽であれば、本体は決して評価されません。

julia> i = 1
1

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

ループから即座に抜け出します。

julia> i = 0
0

julia> while true
           global i += 1
           i > 5 && break
           println(i)
       end
1
2
3
4
5
source
continueKeyword
続ける

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

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

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

try
    open("/danger", "w") do f
        println(f, "Hello")
    end
catch
    @warn "ファイルを書き込めませんでした。"
end

または、ファイルを変数に読み込めない場合:

lines = try
    open("/danger", "r") do f
        readlines(f)
    end
catch
    @warn "ファイルが見つかりません。"
end

構文 catch e(ここで e は任意の変数)は、投げられた例外オブジェクトを catch ブロック内の指定された変数に割り当てます。

try/catch 構文の力は、深くネストされた計算を呼び出し関数のスタックのはるか上のレベルに即座に戻す能力にあります。

source
finallyKeyword
finally

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

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

制御がtryブロックを離れるとき(たとえば、returnによる場合や、単に通常に終了する場合)、close(f)が実行されます。tryブロックが例外によって終了した場合、例外は引き続き伝播します。catchブロックはtryおよびfinallyと組み合わせることもできます。この場合、finallyブロックはcatchがエラーを処理した後に実行されます。

source
quoteKeyword
quote

quote は、明示的な Expr コンストラクタを使用せずに、ブロック内で複数の式オブジェクトを作成します。例えば:

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

他の引用手段である :( ... ) とは異なり、この形式は式ツリーに QuoteNode 要素を導入します。これは、ツリーを直接操作する際に考慮する必要があります。他の目的のために、:( ... )quote .. end ブロックは同じように扱われます。

source
globalKeyword
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
source
outerKeyword
for outer

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

詳細については、変数のスコープに関するマニュアルセクションを参照してください。

また、forも参照してください。

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

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

julia> f()
3
julia> i = 0 # グローバル変数
       for outer i = 1:3
       end
ERROR: syntax: no outer local variable declaration exists for "for outer"
[...]
source
constKeyword
const

const は、値が変わらないグローバル変数を宣言するために使用されます。ほとんどすべてのコード(特にパフォーマンスに敏感なコード)では、グローバル変数はこのように定数として宣言されるべきです。

const x = 5

複数の変数を単一の const で宣言することもできます:

const y, z = 7, 11

const は一つの = 操作にのみ適用されるため、const x = y = 1x を定数として宣言しますが、y はそうではありません。一方、const x = const y = 1xy の両方を定数として宣言します。

「定数性」は可変コンテナには及ばないことに注意してください。変数とその値との関連付けのみが定数です。例えば、x が配列や辞書である場合、要素を変更、追加、または削除することはできます。

場合によっては、const 変数の値を変更するとエラーではなく警告が表示されます。しかし、これは予測不可能な動作を引き起こしたり、プログラムの状態を破損させたりする可能性があるため、避けるべきです。この機能は、インタラクティブな使用中の便宜のためだけに意図されています。

source
structKeyword
struct

Juliaで最も一般的に使用される型はstructで、名前とフィールドのセットとして指定されます。

struct Point
    x
    y
end

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

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

structは<:構文を使用して抽象スーパタイプを宣言することもできます:

struct Point <: AbstractPoint
    x
    y
end

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

コンストラクタの定義方法など、詳細についてはComposite Typesに関するマニュアルのセクションを参照してください。

source
mutable structKeyword
mutable struct

mutable structstruct に似ていますが、構築後に型のフィールドを設定することも可能です。

ミュータブル構造体の個々のフィールドは、const としてマークすることで不変にすることができます:

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

ミュータブル構造体のフィールドに対する const キーワードは、少なくとも Julia 1.8 が必要です。

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

source
Base.@kwdefMacro
@kwdef typedef

これは、typedefという式で宣言された型(structまたはmutable struct式である必要があります)に対して、キーワードベースのコンストラクタを自動的に定義するヘルパーマクロです。デフォルト引数は、field::T = defaultまたはfield = defaultの形式でフィールドを宣言することによって提供されます。デフォルトが提供されない場合、キーワード引数は結果の型コンストラクタにおいて必須のキーワード引数となります。

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

Julia 1.1

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

Julia 1.9

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

julia> @kwdef struct Foo
           a::Int = 1         # 指定されたデフォルト
           b::String          # 必須のキーワード
       end
Foo

julia> Foo(b="hi")
Foo(1, "hi")

julia> Foo()
ERROR: UndefKeywordError: keyword argument `b` not assigned
Stacktrace:
[...]
source
abstract typeKeyword
abstract type

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

abstract type Number end
abstract type Real <: Number end

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

source
primitive typeKeyword
プリミティブ型

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

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

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

source
whereKeyword
where

where キーワードは UnionAll 型を作成します。これは、ある変数のすべての値に対して他の型の反復的な和として考えることができます。例えば、Vector{T} where T<:Real は、要素型が何らかの Real 数であるすべての Vector を含みます。

変数の境界は省略された場合、デフォルトで Any になります:

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

変数には下限も設定できます:

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

ネストされた where 式のための簡潔な構文もあります。例えば、これ:

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

は次のように短縮できます:

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

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

この形式では、変数は外側から内側の順にリストされます。これは、型が T{p1, p2, ...} 構文を使用してパラメータ値に「適用」されるときに、変数が置き換えられる順序と一致します。

source
...Keyword
...

「スプラット」演算子 ... は、引数のシーケンスを表します。... は関数定義で使用でき、関数が任意の数の引数を受け入れることを示します。... はまた、引数のシーケンスに関数を適用するためにも使用できます。

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

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

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

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

; は多くのC系言語と同様にJuliaでも同じ役割を持ち、前の文の終わりを区切るために使用されます。

; は行の終わりに必要ではありませんが、単一の行で文を区切ったり、文を単一の式に結合したりするために使用できます。

REPLで行の終わりに ; を追加すると、その式の結果の印刷を抑制します。

関数の宣言や、オプションで呼び出しの中で、; は通常の引数とキーワードを区切ります。

配列リテラルでは、セミコロンで区切られた引数の内容が結合されます。単一の ; で作られた区切りは垂直に結合します(すなわち、最初の次元に沿って)、;; は水平方向に結合します(第二次元)、;;; は第三次元に沿って結合します、など。このような区切りは、1の長さのトレーリング次元を追加するために、角括弧の最後の位置でも使用できます。

括弧内の最初の位置にある ; は、名前付きタプルを構築するために使用できます。同じ (; ...) 構文を代入の左側で使用すると、プロパティの分解が可能です。

標準の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!"

julia> function plot(x, y; style="solid", width=1, color="black")
           ###
       end

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

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

[:, :, 2] =
 10  20
 30  40

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

julia> nt = (; x=1) # ; またはトレーリングカンマがなければ、これは x に代入されます
(x = 1,)

julia> key = :a; c = 3;

julia> nt2 = (; key => 1, b=2, c, nt.x)
(a = 1, b = 2, c = 3, x = 1)

julia> (; b, x) = nt2; # プロパティの分解を使用して変数 b と x を設定

julia> b, x
(2, 1)

julia> ; # ; を入力すると、プロンプトが(その場で)次のように変更されます: shell>
shell> echo hello
hello
source
=Keyword
=

= は代入演算子です。

  • 変数 a と式 b に対して、a = bab の値に関連付けます。
  • 関数 f(x) に対して、f(x) = x は新しい関数定数 f を定義するか、f がすでに定義されている場合は f に新しいメソッドを追加します。この使い方は function f(x); x; end と同等です。
  • a[i] = vsetindex!(a,v,i) を呼び出します。
  • a.b = csetproperty!(a,:b,c) を呼び出します。
  • 関数呼び出しの中で、f(a=b) はキーワード引数 a の値として b を渡します。
  • カンマ付きの括弧の中で、(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) # in-place & thus more efficient than a = a[a .> 1]
2-element Array{Int64, 1}:
 2
 3
source
?:Keyword
a ? b : c

条件の短縮形; 「a が真なら b を評価し、そうでなければ c を評価する」と読みます。別名 三項演算子.

この構文は if a; b else c end と同等ですが、b または c の値が大きな式の一部として使用されることを強調するためにしばしば使用されます。b または c を評価することによる副作用よりも。

詳細については、制御フロー のマニュアルセクションを参照してください。

julia> x = 1; y = 2;

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

julia> x > y ? "x is larger" : x == y ? "x and y are equal" : "y is larger"
"y is larger"
source

Standard Modules

MainModule
Main

Mainは最上位のモジュールであり、JuliaはMainを現在のモジュールとして開始します。プロンプトで定義された変数はMainに入ります、そしてvarinfoMainの変数をリストします。

julia> @__MODULE__
Main
source
CoreModule
Core

Coreは、言語に「組み込み」と見なされるすべての識別子を含むモジュールです。つまり、コア言語の一部であり、ライブラリではありません。すべてのモジュールは暗黙的にusing Coreを指定します。なぜなら、それらの定義なしでは何もできないからです。

source
BaseModule
Base

Juliaのベースライブラリ。Baseは基本的な機能(base/の内容)を含むモジュールです。すべてのモジュールは暗黙的にusing Baseを含んでおり、これはほとんどのケースで必要です。

source

Base Submodules

Base.BroadcastModule
Base.Broadcast

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

source
Base.DocsModule
Docs

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

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

source
Base.LibcModule

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

source
Base.MetaModule

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

source
Base.StackTracesModule

スタックトレースを収集し操作するためのツール。主にエラーを構築するために使用されます。

source
Base.SysModule

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

source
Base.GCModule
Base.GC

ガーベジコレクションユーティリティを持つモジュール。

source

All Objects

Core.:===Function
===(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
source
Core.isaFunction
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
source
Base.isequalFunction
isequal(x, y) -> Bool

==[@ref]と似ていますが、浮動小数点数と欠損値の扱いが異なります。isequalはすべての浮動小数点NaN値を互いに等しいと見なし、-0.00.0とは異なるものと見なし、missingmissingと等しいと見なします。常にBool値を返します。

isequalは同値関係です - それは反射的(===isequalを含意)、対称的(isequal(a, b)isequal(b, a)を含意)、および推移的(isequal(a, b)およびisequal(b, c)isequal(a, c)を含意)です。

実装

isequalのデフォルト実装は==を呼び出すため、浮動小数点値を含まない型は一般的に==を定義するだけで済みます。

isequalはハッシュテーブル(Dict)で使用される比較関数です。isequal(x,y)hash(x) == hash(y)を含意しなければなりません。

これは通常、カスタム==またはisequalメソッドが存在する型は、対応するhashメソッドを実装しなければならないことを意味します(その逆も同様です)。コレクションは通常、すべての内容に対して再帰的にisequalを呼び出すことでisequalを実装します。

さらに、isequalislessと関連しており、これらは一緒に固定された全順序を定義します。ここで、isequal(x, y)isless(x, y)、またはisless(y, x)のうちの正確に1つがtrueでなければならず(他の2つはfalse)、成り立ちます。

スカラー型は一般的に、浮動小数点数を表す場合を除いて、==とは別にisequalを実装する必要はありません。これは、isnansignbit、および==に基づいて提供される一般的なフォールバックよりも効率的な実装が可能な場合です。

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

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

julia> 0.0 == -0.0
true

julia> isequal(0.0, -0.0)
false

julia> missing == missing
missing

julia> isequal(missing, missing)
true
source
isequal(x)

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

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

source
Base.islessFunction
isless(x, y)

xyより小さいかどうかを、固定された全順序に従ってテストします(isequalと共に定義されています)。islessはすべての型のペア(x, y)に対して定義されているわけではありません。しかし、定義されている場合は、以下の条件を満たすことが期待されます。

  • isless(x, y)が定義されている場合、isless(y, x)およびisequal(x, y)も定義されており、これらの3つのうちの正確に1つがtrueを返します。
  • islessによって定義される関係は推移的であり、すなわちisless(x, y) && isless(y, z)isless(x, z)を意味します。

通常順序付けされない値、例えばNaNは、通常の値の後に順序付けされます。missing値は最後に順序付けされます。

これはsort!によって使用されるデフォルトの比較です。

実装

全順序を持つ非数値型は、この関数を実装する必要があります。数値型は、NaNのような特別な値を持つ場合にのみ実装する必要があります。部分順序を持つ型は<を実装する必要があります。ソートや関連する関数で使用できる代替順序メソッドを定義する方法については、Alternate Orderingsのドキュメントを参照してください。

julia> isless(1, 3)
true

julia> isless("Red", "Blue")
false
source
Base.isunorderedFunction
isunordered(x)

x<に従って順序付けできない値(例えばNaNmissing)である場合、trueを返します。

この述語でtrueと評価される値は、islessなどの他の順序付けに関しては順序付け可能である場合があります。

Julia 1.7

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

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

conditiontrueの場合はxを返し、そうでなければyを返します。これは?ifとは異なり、通常の関数であるため、すべての引数が最初に評価されます。場合によっては、if文の代わりにifelseを使用することで、生成されたコードの分岐を排除し、タイトなループでのパフォーマンスを向上させることができます。

julia> ifelse(1 > 2, 1, 2)
2
source
Core.typeassertFunction
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:
[...]
source
Core.typeofFunction
typeof(x)

xの具体的な型を取得します。

参照: eltype

julia> a = 1//2;

julia> typeof(a)
Rational{Int64}

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

julia> typeof(M)
Matrix{Float64} (alias for Array{Float64, 2})
source
Core.tupleFunction
tuple(xs...)

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

関連情報としては Tuple, ntuple, NamedTuple があります。

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

julia> ans === (1, 'b', π)
true

julia> Tuple(Real[1, 2, pi])  # コレクションを受け取ります
(1, 2, π)
source
Base.ntupleFunction
ntuple(f, n::Integer)

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

julia> ntuple(i -> 2*i, 4)
(2, 4, 6, 8)
source
ntuple(f, ::Val{N})

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

julia> ntuple(i -> 2*i, Val(4))
(2, 4, 6, 8)
source
Base.objectidFunction
objectid(x) -> UInt

オブジェクトのアイデンティティに基づいて x のハッシュ値を取得します。

もし x === y であれば objectid(x) == objectid(y) となり、通常 x !== y の場合は objectid(x) != objectid(y) となります。

他にも hashIdDict を参照してください。

source
Base.hashFunction
hash(x[, h::UInt]) -> UInt

整数ハッシュコードを計算します。isequal(x,y) が成り立つ場合、hash(x)==hash(y) も成り立ちます。オプションの第二引数 h は、結果と混合される別のハッシュコードです。

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

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

julia> a = hash(10)
0x95ea2955abd45275

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

関連情報: objectid, Dict, Set.

source
Base.finalizerFunction
finalizer(f, x)

関数 f(x) を登録して、x へのプログラムからアクセス可能な参照がなくなったときに呼び出されるようにし、x を返します。x の型は mutable struct でなければならず、そうでない場合は関数がエラーをスローします。

f はタスクスイッチを引き起こしてはいけません。これにより、println のようなほとんどの I/O 操作が除外されます。デバッグ目的で、@async マクロを使用して(ファイナライザの外でコンテキストスイッチを遅延させるために)または ccall を使用して C の I/O 関数を直接呼び出すことが役立つ場合があります。

f の実行に対して保証されたワールドエイジはないことに注意してください。ファイナライザが登録されたワールドエイジまたはそれ以降のワールドエイジで呼び出される可能性があります。

finalizer(my_mutable_struct) do x
    @async println("Finalizing $x.")
end

finalizer(my_mutable_struct) do x
    ccall(:jl_safe_printf, Cvoid, (Cstring, Cstring), "Finalizing %s.", repr(x))
end

ファイナライザはオブジェクトの構築時に登録できます。以下の例では、ファイナライザが新しく作成されたミュータブル構造体 x を返すことに暗黙的に依存していることに注意してください。

mutable struct MyMutableStruct
    bar
    function MyMutableStruct(bar)
        x = new(bar)
        f(t) = @async println("Finalizing $t.")
        finalizer(f, x)
    end
end
source
Base.finalizeFunction
finalize(x)

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

source
Base.copyFunction
copy(x)

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

他にも copy!, copyto!, deepcopy を参照してください。

source
Base.deepcopyFunction
deepcopy(x)

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

通常は必要ありませんが、ユーザー定義型は、関数deepcopy_internal(x::T, dict::IdDict)の特別なバージョンを定義することで、デフォルトのdeepcopyの動作をオーバーライドできます(これは他の目的では使用しないべきです)。ここで、Tは特化する型であり、dictは再帰内でこれまでにコピーされたオブジェクトを追跡します。定義内では、deepcopy_internaldeepcopyの代わりに使用し、戻り値を返す前にdict変数を適切に更新する必要があります。

source
Base.getpropertyFunction
getproperty(value, name::Symbol)
getproperty(value, name::Symbol, order::Symbol)

構文 a.bgetproperty(a, :b) を呼び出します。構文 @atomic order a.bgetproperty(a, :b, :order) を呼び出し、構文 @atomic a.bgetproperty(a, :b, :sequentially_consistent) を呼び出します。

julia> struct MyType{T <: Number}
           x::T
       end

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

julia> obj = MyType(1);

julia> obj.special
2

julia> obj.x
1

getproperty は必要な場合にのみオーバーロードすべきです。なぜなら、構文 obj.f の動作が異常であると混乱を招く可能性があるからです。また、メソッドを使用する方がしばしば好ましいことに注意してください。詳細については、このスタイルガイドのドキュメントを参照してください: 直接フィールドアクセスよりもエクスポートされたメソッドを優先する

また、getfieldpropertynames、および setproperty! も参照してください。

source
Base.setproperty!Function
setproperty!(value, name::Symbol, x)
setproperty!(value, name::Symbol, x, order::Symbol)

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

Julia 1.8

モジュールに対する setproperty! は少なくとも Julia 1.8 が必要です。

関連情報として setfield!, propertynames および getproperty を参照してください。

source
Base.replaceproperty!Function
replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

x.fの値をexpectedからdesiredに、egalに従って比較と入れ替えの操作を行います。関数呼び出しの代わりに、@atomicreplace x.f expected => desiredという構文を使用できます。

他にもreplacefield!setproperty!setpropertyonce!を参照してください。

source
Base.swapproperty!Function
swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)

構文 @atomic a.b, _ = c, a.b(c, swapproperty!(a, :b, c, :sequentially_consistent)) を返します。このとき、両側に共通する getproperty 式が1つ必要です。

また、swapfield!setproperty! も参照してください。

source
Base.modifyproperty!Function
modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)

構文 @atomic op(x.f, v)(およびその同等の @atomic x.f op v)は modifyproperty!(x, :f, op, v, :sequentially_consistent) を返します。ここで、最初の引数は getproperty 式でなければならず、原子的に修正されます。

op(getproperty(x, f), v) の呼び出しは、デフォルトでオブジェクト x のフィールド f に格納できる値を返さなければなりません。特に、setproperty! のデフォルトの動作とは異なり、convert 関数は自動的には呼び出されません。

他に modifyfield!setproperty! も参照してください。

source
Base.setpropertyonce!Function
setpropertyonce!(x, f::Symbol, value, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)

x.fに対して比較とスワップ操作を行い、以前に設定されていなければvalueに設定します。関数呼び出し形式の代わりに、構文@atomiconce x.f = valueを使用できます。

関連情報としては、setfieldonce!, setproperty!, replaceproperty!があります。

Julia 1.11

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

source
Base.propertynamesFunction
propertynames(x, private=false)

オブジェクト x のプロパティ(x.property)のタプルまたはベクターを取得します。これは通常 fieldnames(typeof(x)) と同じですが、getproperty をオーバーロードするタイプは、タイプのインスタンスのプロパティを取得するために propertynames もオーバーロードする必要があります。

propertynames(x) は、x の文書化されたインターフェースの一部である「公開」プロパティ名のみを返す場合があります。内部使用を目的とした「プライベート」プロパティ名も返すようにしたい場合は、オプションの第二引数に true を渡してください。x. に対する REPL のタブ補完は、private=false プロパティのみを表示します。

関連情報: hasproperty, hasfield.

source
Base.haspropertyFunction
hasproperty(x, s::Symbol)

オブジェクト xs を自身のプロパティの一つとして持っているかどうかを示すブール値を返します。

Julia 1.2

この関数は少なくとも Julia 1.2 が必要です。

参照: propertynames, hasfield.

source
Core.getfieldFunction
getfield(value, name::Symbol, [order::Symbol])
getfield(value, i::Int, [order::Symbol])

コンポジット value から名前または位置によってフィールドを抽出します。オプションで、操作のための順序を定義できます。フィールドが @atomic として宣言されている場合、その仕様はその位置へのストアと互換性があることが強く推奨されます。そうでない場合、@atomic として宣言されていない場合は、このパラメータは指定されている場合 :not_atomic でなければなりません。詳細は getpropertyfieldnames を参照してください。

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

julia> getfield(a, :num)
1

julia> a.num
1

julia> getfield(a, 1)
1
source
Core.setfield!Function
setfield!(value, name::Symbol, x, [order::Symbol])
setfield!(value, i::Int, x, [order::Symbol])

valueの名前付きフィールドにxを割り当てます。valueは可変でなければならず、xfieldtype(typeof(value), name)のサブタイプでなければなりません。さらに、この操作のために順序を指定することができます。フィールドが@atomicとして宣言されている場合、この指定は必須です。そうでない場合、@atomicとして宣言されていない場合は、指定された場合は:not_atomicでなければなりません。詳細はsetproperty!を参照してください。

julia> mutable struct MyMutableStruct
           field::Int
       end

julia> a = MyMutableStruct(1);

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

julia> getfield(a, :field)
2

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

julia> setfield!(a, :num, 3);
ERROR: setfield!: immutable struct of type Rational cannot be changed
source
Core.modifyfield!Function
modifyfield!(value, name::Symbol, op, x, [order::Symbol]) -> Pair
modifyfield!(value, i::Int, op, x, [order::Symbol]) -> Pair

関数 op を適用した後にフィールドを取得して設定する操作を原子的に実行します。

y = getfield(value, name)
z = op(y, x)
setfield!(value, name, z)
return y => z

ハードウェアがサポートしている場合(例えば、原子的なインクリメント)、これは適切なハードウェア命令に最適化される可能性があります。そうでない場合は、ループを使用します。

Julia 1.7

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

source
Core.replacefield!Function
replacefield!(value, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)
replacefield!(value, i::Int, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

原子操作を実行して、フィールドを指定された値に条件付きで設定します。

y = getfield(value, name, fail_order)
ok = y === expected
if ok
    setfield!(value, name, desired, success_order)
end
return (; old = y, success = ok)

ハードウェアがサポートしている場合、これは適切なハードウェア命令に最適化される可能性があります。そうでない場合は、ループを使用します。

Julia 1.7

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

source
Core.swapfield!Function
swapfield!(value, name::Symbol, x, [order::Symbol])
swapfield!(value, i::Int, x, [order::Symbol])

フィールドを同時に取得して設定する操作を原子的に実行します:

y = getfield(value, name)
setfield!(value, name, x)
return y
Julia 1.7

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

source
Core.setfieldonce!Function
setfieldonce!(value, name::Union{Int,Symbol}, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

与えられた値にフィールドを設定する操作を原子的に実行します。ただし、以前に設定されていなかった場合のみ実行します。

ok = !isdefined(value, name, fail_order)
if ok
    setfield!(value, name, desired, success_order)
end
return ok
Julia 1.11

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

source
Core.isdefinedFunction
isdefined(m::Module, s::Symbol, [order::Symbol])
isdefined(object, s::Symbol, [order::Symbol])
isdefined(object, index::Int, [order::Symbol])

グローバル変数またはオブジェクトフィールドが定義されているかどうかをテストします。引数にはモジュールとシンボル、または複合オブジェクトとフィールド名(シンボルとして)またはインデックスを指定できます。オプションで、操作のための順序を定義できます。フィールドが @atomic として宣言されている場合、その仕様はその位置へのストアと互換性があることが強く推奨されます。そうでない場合、@atomic として宣言されていない場合は、このパラメータは指定されている場合 :not_atomic でなければなりません。

配列要素が定義されているかどうかをテストするには、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
source
Base.@isdefinedMacro
@isdefined s -> Bool

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

フィールドプロパティについては isdefined を、配列インデックスについては isassigned を、その他のマッピングについては haskey を参照してください。

julia> @isdefined newvar
false

julia> newvar = 1
1

julia> @isdefined newvar
true

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

julia> f()
false
true
source
Base.convertFunction
convert(T, x)

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

TInteger型の場合、xTで表現できない場合(例えば、xが整数値でない場合や、Tがサポートする範囲外の場合)には、InexactErrorが発生します。

julia> convert(Int, 3.0)
3

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

TAbstractFloat型の場合、Tで表現可能なxに最も近い値が返されます。Infは、最も近い値を決定する目的でfloatmax(T)よりも1 ulp大きいものとして扱われます。

julia> x = 1/3
0.3333333333333333

julia> convert(Float32, x)
0.33333334f0

julia> convert(BigFloat, x)
0.333333333333333314829616256247390992939472198486328125

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

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

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

julia> y === x
true

関連項目: round, trunc, oftype, reinterpret. ```

source
Base.promoteFunction
promote(xs...)

すべての引数を共通の型に変換し、それらをすべて(タプルとして)返します。引数を変換できない場合は、エラーが発生します。

関連情報: promote_type, promote_rule.

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

julia> promote_type(Int8, Float16, Float32)
Float32

julia> reduce(Base.promote_typejoin, (Int8, Float16, Float32))
Real

julia> promote(1, "x")
ERROR: promotion of types Int64 and String failed to change any arguments
[...]

julia> promote_type(Int, String)
Any
source
Base.oftypeFunction
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
source
Base.widenFunction
widen(x)

x が型である場合、算術演算 + および - が、型 x が保持できる値の任意の組み合わせに対してオーバーフローや精度の損失がないことが保証される「大きな」型を返します。

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

x が値である場合、widen(typeof(x)) に変換されます。

julia> widen(Int32)
Int64

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

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

関連項目: one, oneunit, および LinearAlgebraI

julia> identity("Well, what did you expect?")
"Well, what did you expect?"
source
Core.WeakRefType
WeakRef(x)

w = WeakRef(x) は、Juliaの値 x への 弱参照 を構築します:wx への参照を含んでいますが、x がガーベジコレクトされるのを防ぎません。w.value は、x がまだガーベジコレクトされていない場合は x であり、x がガーベジコレクトされている場合は nothing です。

julia> x = "a string"
"a string"

julia> w = WeakRef(x)
WeakRef("a string")

julia> GC.gc()

julia> w           # `x` を介して参照が維持されます
WeakRef("a string")

julia> x = nothing # 参照をクリア

julia> GC.gc()

julia> w
WeakRef(nothing)
source

Properties of Types

Type relations

Base.supertypeFunction
supertype(T::DataType)

DataType T のスーパタイプを返します。

julia> supertype(Int32)
Signed
source
Core.TypeType
Core.Type{T}

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

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

julia> isa(Float64, Type)
true

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

julia> isa(Real, Type{Real})
true
source
Core.DataTypeType
DataType <: Type{T}

DataTypeは、名前が付けられた明示的に宣言された型、明示的に宣言されたスーパタイプ、およびオプションでパラメータを持つ型を表します。システム内のすべての具体的な値は、何らかのDataTypeのインスタンスです。

julia> typeof(Real)
DataType

julia> typeof(Int)
DataType

julia> struct Point
           x::Int
           y
       end

julia> typeof(Point)
DataType
source
Core.:<:Function
<:(T1, T2)

サブタイプ演算子: 型 T1 のすべての値が型 T2 の値でもある場合に限り true を返します。

julia> Float64 <: AbstractFloat
true

julia> Vector{Int} <: AbstractArray
true

julia> Matrix{Float64} <: Matrix{AbstractFloat}
false
source
Base.:>:Function
>:(T1, T2)

スーパタイプ演算子で、T2 <: T1 と同等です。

source
Base.typejoinFunction
typejoin(T, S, ...)

TS の最も近い共通の祖先を返します。つまり、両方が継承する最も狭い型です。追加の varargs に対して再帰します。

julia> typejoin(Int, Float64)
Real

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

TS の交差を含む型を計算します。通常、これは最小のそのような型、またはそれに近いものになります。

正確な動作が保証される特別なケース: T <: S の場合、typeintersect(S, T) == T == typeintersect(T, S) です。

source
Base.promote_typeFunction
promote_type(type1, type2, ...)

プロモーションは、混合型の値を単一の共通型に変換することを指します。promote_typeは、異なる型の引数が与えられたときのJuliaにおけるデフォルトのプロモーション動作を表します。promote_typeは、一般的に、過度に広がることなく、少なくともどちらの入力型のほとんどの値を近似できる型を返そうとします。いくらかの損失は許容されます。たとえば、promote_type(Int64, Float64)は、厳密にはすべてのInt64値が正確にFloat64値として表現できるわけではありませんが、Float64を返します。

関連情報: promote, promote_typejoin, promote_rule

julia> promote_type(Int64, Float64)
Float64

julia> promote_type(Int32, Int64)
Int64

julia> promote_type(Float32, BigInt)
BigFloat

julia> promote_type(Int16, Float16)
Float16

julia> promote_type(Int64, Float16)
Float16

julia> promote_type(Int8, UInt16)
UInt16
この関数を直接オーバーロードしないでください

自分の型のためにプロモーションをオーバーロードするには、promote_ruleをオーバーロードする必要があります。promote_typeは、型を決定するために内部的にpromote_ruleを呼び出します。promote_typeを直接オーバーロードすると、曖昧さのエラーが発生する可能性があります。

```

source
Base.promote_ruleFunction
promote_rule(type1, type2)

type1type2 の型の値が与えられたときに promote が使用すべき型を指定します。この関数は直接呼び出すべきではなく、新しい型に対して適切に定義を追加する必要があります。

source
Base.promote_typejoinFunction
promote_typejoin(T, S)

TSの両方を含む型を計算します。これは、両方の型の親であるか、適切であればUnionになる可能性があります。typejoinにフォールバックします。

代わりにpromotepromote_typeを参照してください。

julia> Base.promote_typejoin(Int, Float64)
Real

julia> Base.promote_type(Int, Float64)
Float64
source
Base.isdispatchtupleFunction
isdispatchtuple(T)

T がタプルの「リーフ型」であるかどうかを判断します。これは、ディスパッチの型シグネチャに現れる可能性があり、呼び出しに現れる可能性のあるサブタイプ(またはスーパタイプ)を持たないことを意味します。もし T が型でない場合は、false を返します。

source

Declared structure

Base.ismutableFunction
ismutable(v) -> Bool

v がミュータブルである場合にのみ true を返します。イミュータビリティについての議論は Mutable Composite Types を参照してください。この関数は値に対して動作するため、DataType を与えると、その型の値がミュータブルであると教えてくれます。

Note

技術的な理由から、ismutable は特定の特殊型(例えば StringSymbol)の値に対して true を返しますが、これらは許可された方法で変更できません。

他にも isbitsisstructtype を参照してください。

julia> ismutable(1)
false

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

この関数は少なくとも Julia 1.5 が必要です。

source
Base.isimmutableFunction
isimmutable(v) -> Bool
Warning

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

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

julia> isimmutable(1)
true

julia> isimmutable([1,2])
false
source
Base.ismutabletypeFunction
ismutabletype(T) -> Bool

T が可変型として宣言されたかどうかを判断します(すなわち、mutable struct キーワードを使用して)。T が型でない場合は、false を返します。

Julia 1.7

この関数は少なくとも Julia 1.7 が必要です。

source
Base.isabstracttypeFunction
isabstracttype(T)

T が抽象型として宣言されたかどうかを判断します(つまり、abstract type 構文を使用して)。これは isconcretetype(T) の否定ではないことに注意してください。もし T が型でない場合は、false を返します。

julia> isabstracttype(AbstractArray)
true

julia> isabstracttype(Vector)
false
source
Base.isprimitivetypeFunction
isprimitivetype(T) -> Bool

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

source
Base.issingletontypeFunction
Base.issingletontype(T)

T が正確に1つのインスタンスを持つかどうかを判断します。たとえば、他のシングルトン値を除いてフィールドを持たない構造体型です。T が具体的な型でない場合は、false を返します。

source
Base.isstructtypeFunction
isstructtype(T) -> Bool

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

source
Base.nameofMethod
nameof(t::DataType) -> Symbol

DataType(潜在的に UnionAll でラップされた) の名前を親モジュールなしでシンボルとして取得します。

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

julia> nameof(Foo.S{T} where T)
:S
source
Base.fieldnamesFunction
fieldnames(x::DataType)

DataTypeのフィールドの名前を持つタプルを取得します。

関連情報としては、propertynameshasfieldがあります。

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

julia> fieldnames(typeof(1+im))
(:re, :im)
source
Base.fieldnameFunction
fieldname(x::DataType, i::Integer)

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

julia> fieldname(Rational, 1)
:num

julia> fieldname(Rational, 2)
:den
source
Core.fieldtypeFunction
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
source
Base.fieldtypesFunction
fieldtypes(T::Type)

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

Julia 1.1

この関数は少なくとも Julia 1.1 が必要です。

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

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

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

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

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

fieldnamesfieldcounthaspropertyも参照してください。

Julia 1.2

この関数は少なくともJulia 1.2が必要です。

julia> struct Foo
            bar::Int
       end

julia> hasfield(Foo, :bar)
true

julia> hasfield(Foo, :x)
false
source
Core.nfieldsFunction
nfields(x) -> Int

与えられたオブジェクトのフィールドの数を取得します。

julia> a = 1//2;

julia> nfields(a)
2

julia> b = 1
1

julia> nfields(b)
0

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

julia> nfields(ex)
1

これらの例では、aRational で、2つのフィールドを持っています。bInt で、フィールドを持たないプリミティブビットタイプです。exErrorException で、1つのフィールドを持っています。

source
Base.isconstFunction
isconst(m::Module, s::Symbol) -> Bool

指定されたモジュール m でグローバルが const として宣言されているかどうかを判断します。

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

与えられた型 t において、フィールド sconst として宣言されているかどうかを判断します。

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

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

source

Memory layout

Base.sizeofMethod
sizeof(T::DataType)
sizeof(obj)

与えられた DataType T の標準的なバイナリ表現のサイズ(バイト単位)。または、DataType でない場合はオブジェクト obj のサイズ(バイト単位)。

Base.summarysize も参照してください。

julia> sizeof(Float32)
4

julia> sizeof(ComplexF64)
16

julia> sizeof(1.0)
8

julia> sizeof(collect(1.0:10.0))
80

julia> struct StructWithPadding
           x::Int64
           flag::Bool
       end

julia> sizeof(StructWithPadding) # パディングのためフィールドの `sizeof` の合計ではない
16

julia> sizeof(Int64) + sizeof(Bool) # 上記とは異なる
9

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

julia> sizeof(AbstractArray)
ERROR: 抽象型 AbstractArray には明確なサイズがありません。
Stacktrace:
[...]
source
Base.isconcretetypeFunction
isconcretetype(T)

T が具体的な型であるかどうかを判断します。具体的な型とは、直接的なインスタンス(typeof(x) === T となる値 x)を持つ可能性がある型を意味します。これは isabstracttype(T) の否定ではないことに注意してください。T が型でない場合は、false を返します。

関連情報: isbits, isabstracttype, issingletontype.

julia> isconcretetype(Complex)
false

julia> isconcretetype(Complex{Float32})
true

julia> isconcretetype(Vector{Complex})
true

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

julia> isconcretetype(Union{})
false

julia> isconcretetype(Union{Int,String})
false
source
Base.isbitstypeFunction
isbitstype(T)

T が「プレーンデータ」型である場合は true を返します。これは、型 T が不変であり、他の値への参照を含まず、primitive 型および他の isbitstype 型のみを含むことを意味します。典型的な例としては、UInt8Float64、および Complex{Float64} のような数値型があります。このカテゴリの型は重要であり、型パラメータとして有効であり、isdefined / isassigned ステータスを追跡しない可能性があり、C と互換性のある定義されたレイアウトを持っています。もし T が型でない場合は、false を返します。

他にも isbitsisprimitivetypeismutable を参照してください。

julia> isbitstype(Complex{Float64})
true

julia> isbitstype(Complex)
false
source
Base.fieldoffsetFunction
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)
13-element Vector{Tuple{UInt64, Symbol, Type}}:
 (0x0000000000000000, :desc, Union{RawFD, String})
 (0x0000000000000008, :device, UInt64)
 (0x0000000000000010, :inode, UInt64)
 (0x0000000000000018, :mode, UInt64)
 (0x0000000000000020, :nlink, Int64)
 (0x0000000000000028, :uid, UInt64)
 (0x0000000000000030, :gid, UInt64)
 (0x0000000000000038, :rdev, UInt64)
 (0x0000000000000040, :size, Int64)
 (0x0000000000000048, :blksize, Int64)
 (0x0000000000000050, :blocks, Int64)
 (0x0000000000000058, :mtime, Float64)
 (0x0000000000000060, :ctime, Float64)
source
Base.datatype_alignmentFunction
Base.datatype_alignment(dt::DataType) -> Int

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

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

この型のインスタンスのフィールドがメモリ内でパッキングされているかどうかを返します。すなわち、構造体のフィールドに適用されたときに等価テストに一意に影響を与えないビット(パディングビットと定義される)を介さずに格納されているかどうかです。isconcretetypeに対して呼び出すことができます。

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

この型のインスタンスがガベージコレクション管理メモリへの参照を含むことができるかどうかを返します。isconcretetype の任意のものに対して呼び出すことができます。

source

Special values

Base.typeminFunction
typemin(T)

与えられた(実数の)数値データ型 T によって表現可能な最小値。

参照: floatmin, typemax, eps

julia> typemin(Int8)
-128

julia> typemin(UInt32)
0x00000000

julia> typemin(Float16)
-Inf16

julia> typemin(Float32)
-Inf32

julia> nextfloat(-Inf32)  # 最小の有限 Float32 浮動小数点数
-3.4028235f38
source
Base.typemaxFunction
typemax(T)

指定された(実数の)数値 DataType が表現できる最大値。

関連情報: floatmax, typemin, eps

julia> typemax(Int8)
127

julia> typemax(UInt32)
0xffffffff

julia> typemax(Float64)
Inf

julia> typemax(Float32)
Inf32

julia> floatmax(Float32)  # 最大の有限 Float32 浮動小数点数
3.4028235f38
source
Base.floatminFunction
floatmin(T = Float64)

浮動小数点型 T で表現可能な最小の正の正規数を返します。

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

julia> floatmin(Float32)
1.1754944f-38

julia> floatmin()
2.2250738585072014e-308
source
Base.floatmaxFunction
floatmax(T = Float64)

浮動小数点型 T で表現可能な最大の有限数を返します。

関連情報: typemax, floatmin, eps

julia> floatmax(Float16)
Float16(6.55e4)

julia> floatmax(Float32)
3.4028235f38

julia> floatmax()
1.7976931348623157e308

julia> typemax(Float64)
Inf
source
Base.maxintfloatFunction
maxintfloat(T=Float64)

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

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

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

source
maxintfloat(T, S)

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

source
Base.epsMethod
eps(::Type{T}) where T<:AbstractFloat
eps()

浮動小数点型 Tマシンイプシロン を返します(デフォルトは T = Float64)。これは、1 と typeof(one(T)) で表現可能な次に大きい値との間のギャップとして定義され、eps(one(T)) と同等です。(eps(T)T相対誤差 の上限であるため、one のような「次元のない」量です。)

julia> eps()
2.220446049250313e-16

julia> eps(Float32)
1.1920929f-7

julia> 1.0 + eps()
1.0000000000000002

julia> 1.0 + eps()/2
1.0
source
Base.epsMethod
eps(x::AbstractFloat)

x最下位単位(ulp)を返します。これは、xにおける連続する表現可能な浮動小数点値の間の距離です。ほとんどの場合、xの両側の距離が異なる場合は、2つのうち大きい方が取られます。つまり、

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

このルールの例外は、最小および最大の有限値(例えば、Float64nextfloat(-Inf)およびprevfloat(Inf))であり、これらは値の小さい方に丸められます。

この動作の理由は、epsが浮動小数点の丸め誤差を制限するためです。デフォルトのRoundNearest丸めモードの下で、$y$が実数であり、$x$$y$に最も近い浮動小数点数である場合、次の不等式が成り立ちます。

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

関連情報: nextfloat, issubnormal, floatmax

julia> eps(1.0)
2.220446049250313e-16

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

julia> eps(2.0)
4.440892098500626e-16

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

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

julia> x + prevfloat(eps(x)/2) # 切り下げ
1.7976931348623157e308
source
Base.instancesFunction
instances(T::Type)

指定された型のすべてのインスタンスのコレクションを返します。主に列挙型に使用されます(@enumを参照)。

julia> @enum Color red blue green

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

Special Types

Core.AnyType
Any::DataType

Any はすべての型の和集合です。任意の x に対して isa(x, Any) == true という定義的な性質を持っています。したがって、Any は可能な値の全宇宙を表します。例えば、IntegerIntInt8、および他の整数型を含む Any のサブセットです。

source
Core.UnionType
Union{Types...}

Union型は、その引数型のいずれかのインスタンスをすべて含む抽象型です。これは、T <: Union{T,S} および S <: Union{T,S} を意味します。

他の抽象型と同様に、すべての引数が非抽象であっても、インスタンス化することはできません。

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

julia> 1 isa IntOrString # Intのインスタンスはユニオンに含まれています
true

julia> "Hello!" isa IntOrString # Stringも含まれています
true

julia> 1.0 isa IntOrString # Float64はIntでもAbstractStringでもないため含まれていません
false

拡張ヘルプ

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

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

source
Union{}Keyword
Union{}

Union{}、型の空の Union は、値を持たない型です。つまり、任意の x に対して isa(x, Union{}) == false という定義的な性質を持っています。Base.Bottom はそのエイリアスとして定義されており、Union{} の型は Core.TypeofBottom です。

julia> isa(nothing, Union{})
false
source
Core.UnionAllType
UnionAll

型パラメータのすべての値にわたる型の和。UnionAllは、いくつかのパラメータの値が不明な場合のパラメトリック型を説明するために使用されます。UnionAll Typesに関するマニュアルのセクションを参照してください。

julia> typeof(Vector)
UnionAll

julia> typeof(Vector{Int})
DataType
source
Core.TupleType
Tuple{Types...}

タプルは、異なる型の任意の値を保持できる固定長のコンテナですが、変更することはできません(不変です)。値はインデックスを介してアクセスできます。タプルリテラルはカンマと括弧で書かれます:

julia> (1, 1+1)
(1, 2)

julia> (1,)
(1,)

julia> x = (0.0, "hello", 6*7)
(0.0, "hello", 42)

julia> x[2]
"hello"

julia> typeof(x)
Tuple{Float64, String, Int64}

長さ1のタプルはカンマを付けて書く必要があります (1,)(1) は単に括弧で囲まれた値になります。() は空の(長さ0の)タプルを表します。

タプルは、コンストラクタとして Tuple 型を使用することでイテレータから構築できます:

julia> Tuple(["a", 1])
("a", 1)

julia> Tuple{String, Float64}(["a", 1])
("a", 1.0)

タプル型はそのパラメータに対して共変です:Tuple{Int}Tuple{Any} のサブタイプです。したがって、Tuple{Any} は抽象型と見なされ、タプル型はそのパラメータが具体的である場合にのみ具体的です。タプルにはフィールド名はなく、フィールドはインデックスでのみアクセスされます。タプル型は任意の数のパラメータを持つことができます。

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

また、VarargNTuplentupletupleNamedTupleも参照してください。

source
Core.NTupleType
NTuple{N, T}

長さ N のタプルの型を表すコンパクトな方法で、すべての要素は型 T です。

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

関連項目として ntuple を参照してください。

source
Core.NamedTupleType
NamedTuple

NamedTupleは、その名前が示すように、名前付きTupleです。つまり、各エントリが一意の名前を持つ、タプルのような値のコレクションです。この名前はSymbolとして表されます。Tupleと同様に、NamedTupleは不変であり、構築後に名前や値をその場で変更することはできません。

名前付きタプルは、キーを持つタプルリテラルとして作成できます。例えば、(a=1, b=2)や、開き括弧の後にセミコロンを付けたタプルリテラルとして、例えば(; a=1, b=2)(この形式は、以下に説明するようにプログラムで生成された名前も受け入れます)や、コンストラクタとしてNamedTuple型を使用して、例えばNamedTuple{(:a, :b)}((1,2))のように作成できます。

名前付きタプル内の名前に関連付けられた値にアクセスするには、フィールドアクセス構文を使用します。例えば、x.agetindexを使用して、x[:a]またはx[(:a, :b)]のようにアクセスできます。名前のタプルはkeysを使用して取得でき、値のタプルはvaluesを使用して取得できます。

Note

NamedTupleを反復処理すると、が名前なしで生成されます。(以下の例を参照してください。)名前と値のペアを反復処理するには、pairs関数を使用してください。

@NamedTupleマクロは、NamedTuple型を便利に宣言するために使用できます。

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

julia> x.a
1

julia> x[:a]
1

julia> x[(:a,)]
(a = 1,)

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

julia> values(x)
(1, 2)

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

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

キーワード引数をプログラム的に定義するのと同様に、名前付きタプルは、タプルリテラル内のセミコロンの後にname::Symbol => valueのペアを指定することで作成できます。この形式とname=value構文は混在させることができます:

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

名前と値のペアは、名前付きタプルをスプラットするか、各シンボルを最初の値として持つ2値コレクションを生成するイテレータを使用して提供することもできます:

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

julia> NamedTuple{keys}(values)
(a = 1, b = 2, c = 3)

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

julia> nt1 = (a=1, b=2);

julia> nt2 = (c=3, d=4);

julia> (; nt1..., nt2..., b=20) # 最後のbはnt1からの値を上書きします
(a = 1, b = 20, c = 3, d = 4)

julia> (; zip(keys, values)...) # zipは(:a, 1)のようなタプルを生成します
(a = 1, b = 2, c = 3)

キーワード引数と同様に、識別子とドット式は名前を暗示します:

julia> x = 0
0

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

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

識別子とドット式からの暗黙の名前は、Julia 1.5以降で利用可能です。

Julia 1.7

複数のSymbolを持つgetindexメソッドの使用は、Julia 1.7以降で利用可能です。

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

このマクロは、NamedTuple 型を宣言するためのより便利な構文を提供します。与えられたキーと型を持つ NamedTuple 型を返し、これは NamedTuple{(:key1, :key2, ...), Tuple{Type1,Type2,...}} と同等です。::Type 宣言が省略された場合、それは Any と見なされます。begin ... end 形式は、宣言を複数行に分けることを可能にします(struct 宣言に似ています)が、それ以外は同等です。NamedTuple マクロは、NamedTuple 型を印刷する際に使用されます。例えば、タプル (a=3.1, b="hello") は型 NamedTuple{(:a, :b), Tuple{Float64, String}} を持ち、これは次のように @NamedTuple を使って宣言することもできます:

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

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

このマクロは Julia 1.5 以降で利用可能です。

source
Base.@KwargsMacro
@Kwargs{key1::Type1, key2::Type2, ...}

このマクロは、@NamedTupleと同じ構文からキーワード引数の型表現を構築する便利な方法を提供します。例えば、func([位置引数]; kw1=1.0, kw2="2")のような関数呼び出しがある場合、このマクロを使用してキーワード引数の内部型表現を@Kwargs{kw1::Float64, kw2::String}として構築できます。マクロの構文は、スタックトレースビューに印刷されるときにキーワードメソッドのシグネチャ型を簡素化するように特別に設計されています。

julia> @Kwargs{init::Int} # キーワード引数の内部表現
Base.Pairs{Symbol, Int64, Tuple{Symbol}, @NamedTuple{init::Int64}}

julia> sum("julia"; init=1)
ERROR: MethodError: no method matching +(::Char, ::Char)
関数 `+` は存在しますが、この引数型の組み合わせに対して定義されたメソッドはありません。

最も近い候補は次のとおりです:
  +(::Any, ::Any, ::Any, ::Any...)
   @ Base operators.jl:585
  +(::Integer, ::AbstractChar)
   @ Base char.jl:247
  +(::T, ::Integer) where T<:AbstractChar
   @ Base char.jl:237

スタックトレース:
  [1] add_sum(x::Char, y::Char)
    @ Base ./reduce.jl:24
  [2] BottomRF
    @ Base ./reduce.jl:86 [インライン]
  [3] _foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, init::Int64, itr::String)
    @ Base ./reduce.jl:62
  [4] foldl_impl(op::Base.BottomRF{typeof(Base.add_sum)}, nt::Int64, itr::String)
    @ Base ./reduce.jl:48 [インライン]
  [5] mapfoldl_impl(f::typeof(identity), op::typeof(Base.add_sum), nt::Int64, itr::String)
    @ Base ./reduce.jl:44 [インライン]
  [6] mapfoldl(f::typeof(identity), op::typeof(Base.add_sum), itr::String; init::Int64)
    @ Base ./reduce.jl:175 [インライン]
  [7] mapreduce(f::typeof(identity), op::typeof(Base.add_sum), itr::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:307 [インライン]
  [8] sum(f::typeof(identity), a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:535 [インライン]
  [9] sum(a::String; kw::@Kwargs{init::Int64})
    @ Base ./reduce.jl:564 [インライン]
 [10] トップレベルスコープ
    @ REPL[12]:1
Julia 1.10

このマクロはJulia 1.10以降で利用可能です。

source
Base.ValType
Val(c)

Val{c}()を返します。これはランタイムデータを含みません。このような型は、cの値を介して関数間で情報を渡すために使用できます。cisbits値またはSymbolでなければなりません。この構造の意図は、定数の値をランタイムでテストすることなく、コンパイル時に直接定数に基づいてディスパッチできるようにすることです。

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

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

julia> f(Val(true))
"Good"
source
Core.VarargConstant
Vararg{T,N}

タプル型 Tuple の最後のパラメータは特別な値 Vararg であり、これは任意の数の末尾要素を示します。 Vararg{T,N} は、型 T の正確に N 個の要素に対応します。最後に、 Vararg{T} は型 T のゼロ個以上の要素に対応します。 Vararg タプル型は、可変引数メソッドが受け入れる引数を表すために使用されます(マニュアルの Varargs Functions セクションを参照してください)。

また、 NTuple も参照してください。

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

julia> isa(("1",), mytupletype)
true

julia> isa(("1",1), mytupletype)
true

julia> isa(("1",1,2), mytupletype)
true

julia> isa(("1",1,2,3.0), mytupletype)
false
source
Base.isnothingFunction
isnothing(x)

x === nothing の場合は true を返し、そうでない場合は false を返します。

Julia 1.1

この関数は少なくとも Julia 1.1 が必要です。

関連項目として somethingBase.notnothingismissing を参照してください。

source
Base.notnothingFunction
notnothing(x)

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

source
Base.SomeType
Some{T}

Union{Some{T}, Nothing}で値の不在(nothing)とnothing値の存在(すなわちSome(nothing))を区別するために使用されるラッパー型です。

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

source
Base.somethingFunction
something(x...)

引数の中で nothing と等しくない最初の値を返します。もし存在しない場合はエラーをスローします。型 Some の引数はアンラップされます。

関連情報として coalesceskipmissing@something も参照してください。

julia> something(nothing, 1)
1

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

julia> something(Some(nothing), 2) === nothing
true

julia> something(missing, nothing)
missing

julia> something(nothing, nothing)
ERROR: ArgumentError: No value arguments present
source
Base.@somethingMacro
@something(x...)

something の短絡バージョンです。

julia> f(x) = (println("f($x)"); nothing);

julia> a = 1;

julia> a = @something a f(2) f(3) error("`a` のデフォルトが見つかりません")
1

julia> b = nothing;

julia> b = @something b f(2) f(3) error("`b` のデフォルトが見つかりません")
f(2)
f(3)
ERROR: `b` のデフォルトが見つかりません
[...]

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

julia> b === nothing
true
Julia 1.7

このマクロは Julia 1.7 以降で利用可能です。

source
Base.Enums.@enumMacro
@enum EnumName[::BaseType] value1[=x] value2[=y]

Enum{BaseType}のサブタイプを作成し、名前をEnumName、列挙メンバーの値をvalue1value2、それぞれオプションで割り当てられた値xyを持ちます。EnumNameは他の型と同様に使用でき、列挙メンバーの値は通常の値として使用できます。例えば、

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

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

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

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

値はbeginブロック内でも指定できます。例えば、

@enum EnumName begin
    value1
    value2
end

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

列挙のすべてのインスタンスをリストするにはinstancesを使用します。例えば、

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

列挙インスタンスからシンボルを構築することも可能です:

julia> Symbol(apple)
:apple
source
Core.ExprType
Expr(head::Symbol, args...)

解析されたJuliaコード(AST)における複合式を表す型です。各式は、どの種類の式であるかを識別するhead Symbol(例えば、呼び出し、forループ、条件文など)と、サブ式(例えば、呼び出しの引数)で構成されています。サブ式は、argsというVector{Any}フィールドに格納されます。

メタプログラミングに関するマニュアルの章と、開発者向けドキュメントJulia ASTsを参照してください。

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

julia> dump(:(a ? b : c))
Expr
  head: Symbol if
  args: Array{Any}((3,))
    1: Symbol a
    2: Symbol b
    3: Symbol c
source
Core.SymbolType
シンボル

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

julia> :name
:name

julia> typeof(:name)
Symbol

julia> x = 42
42

julia> eval(:x)
42

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

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

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

source
Core.SymbolMethod
Symbol(x...) -> Symbol

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

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

julia> Symbol("day", 4)
:day4
source
Core.ModuleType
モジュール

Moduleは別のグローバル変数ワークスペースです。詳細については、moduleおよびモジュールに関するマニュアルセクションを参照してください。

Module(name::Symbol=:anonymous, std_imports=true, default_names=true)

指定された名前のモジュールを返します。baremoduleModule(:ModuleName, false)に対応します。

名前を全く含まない空のモジュールは、Module(:ModuleName, false, false)を使用して作成できます。このモジュールはBaseCoreをインポートせず、自身への参照を含みません。

source

Generic Functions

Core.FunctionType
関数

すべての関数の抽象型。

julia> isa(+, Function)
true

julia> typeof(sin)
typeof(sin) (関数 sin の単一型、Function のサブタイプ)

julia> ans <: Function
true
source
Base.hasmethodFunction
hasmethod(f, t::Type{<:Tuple}[, kwnames]; world=get_world_counter()) -> Bool

与えられた汎用関数が、指定された引数の型の Tuple に一致するメソッドを持っているかどうかを判断します。world によって与えられる世界の年齢の上限も考慮されます。

キーワード引数名のタプル kwnames が提供されている場合、これはまた、f のメソッドが t に一致し、指定されたキーワード引数名を持っているかどうかもチェックします。一致するメソッドが可変数のキーワード引数を受け入れる場合、例えば kwargs... のように、kwnames に与えられた名前は有効と見なされます。そうでない場合、提供された名前はメソッドのキーワード引数のサブセットでなければなりません。

詳細は applicable を参照してください。

Julia 1.2

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

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

julia> f(; oranges=0) = oranges;

julia> hasmethod(f, Tuple{}, (:oranges,))
true

julia> hasmethod(f, Tuple{}, (:apples, :bananas))
false

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

julia> hasmethod(g, Tuple{}, (:a, :b, :c, :d))  # g は任意の kwargs を受け入れる
true
source
Core.applicableFunction
applicable(f, args...) -> Bool

与えられた汎用関数に対して、与えられた引数に適用可能なメソッドがあるかどうかを判断します。

参照: hasmethod

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

julia> applicable(f, 1)
false

julia> applicable(f, 1, 2)
true
source
Base.isambiguousFunction
Base.isambiguous(m1, m2; ambiguous_bottom=false) -> Bool

2つのメソッド m1m2 が、ある呼び出しシグネチャに対して曖昧であるかどうかを判断します。このテストは、同じ関数の他のメソッドの文脈で実行されます。孤立している場合、m1m2 は曖昧である可能性がありますが、曖昧さを解決する第三のメソッドが定義されている場合、これは false を返します。逆に、孤立している場合、m1m2 は順序付けられている可能性がありますが、第三のメソッドがそれらと一緒にソートできない場合、共に曖昧さを引き起こす可能性があります。

パラメトリック型の場合、ambiguous_bottom キーワード引数は、Union{} が型パラメータの曖昧な交差としてカウントされるかどうかを制御します。true の場合、曖昧と見なされ、false の場合はそうではありません。

julia> foo(x::Complex{<:Integer}) = 1
foo (generic function with 1 method)

julia> foo(x::Complex{<:Rational}) = 2
foo (generic function with 2 methods)

julia> m1, m2 = collect(methods(foo));

julia> typeintersect(m1.sig, m2.sig)
Tuple{typeof(foo), Complex{Union{}}}

julia> Base.isambiguous(m1, m2, ambiguous_bottom=true)
true

julia> Base.isambiguous(m1, m2, ambiguous_bottom=false)
false
source
Core.invokeFunction
invoke(f, argtypes::Type, args...; kwargs...)

指定された引数 args に対して、指定された型 argtypes に一致する与えられた汎用関数 f のメソッドを呼び出します。引数 argsargtypes で指定された型に準拠している必要があり、すなわち自動的な変換は行われません。このメソッドは、最も特定の一致するメソッド以外のメソッドを呼び出すことを可能にし、より一般的な定義の動作が明示的に必要な場合に便利です(しばしば同じ関数のより特定のメソッドの実装の一部として)。

自分が書いていない関数に対して invoke を使用する際は注意が必要です。与えられた argtypes に対してどの定義が使用されるかは、関数が特定の argtypes での呼び出しが公開APIの一部であると明示的に述べていない限り、実装の詳細です。例えば、以下の例での 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
source
Base.@invokeMacro
@invoke f(arg::T, ...; kwargs...)

invokeを呼び出す便利な方法を提供し、@invoke f(arg1::T1, arg2::T2; kwargs...)invoke(f, Tuple{T1,T2}, arg1, arg2; kwargs...)に展開します。引数の型注釈が省略されると、その引数のCore.Typeofに置き換えられます。引数が型指定されていないか、明示的にAnyとして型指定されているメソッドを呼び出すには、引数に::Anyで注釈を付けます。

以下の構文もサポートしています:

  • @invoke (x::X).finvoke(getproperty, Tuple{X,Symbol}, x, :f)に展開されます。
  • @invoke (x::X).f = v::Vinvoke(setproperty!, Tuple{X,Symbol,V}, x, :f, v)に展開されます。
  • @invoke (xs::Xs)[i::I]invoke(getindex, Tuple{Xs,I}, xs, i)に展開されます。
  • @invoke (xs::Xs)[i::I] = v::Vinvoke(setindex!, Tuple{Xs,V,I}, xs, v, i)に展開されます。

julia> @macroexpand @invoke f(x::T, y)
:(Core.invoke(f, Tuple{T, Core.Typeof(y)}, x, y))

julia> @invoke 420::Integer % Unsigned
0x00000000000001a4

julia> @macroexpand @invoke (x::X).f
:(Core.invoke(Base.getproperty, Tuple{X, Core.Typeof(:f)}, x, :f))

julia> @macroexpand @invoke (x::X).f = v::V
:(Core.invoke(Base.setproperty!, Tuple{X, Core.Typeof(:f), V}, x, :f, v))

julia> @macroexpand @invoke (xs::Xs)[i::I]
:(Core.invoke(Base.getindex, Tuple{Xs, I}, xs, i))

julia> @macroexpand @invoke (xs::Xs)[i::I] = v::V
:(Core.invoke(Base.setindex!, Tuple{Xs, V, I}, xs, v, i))
Julia 1.7

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

Julia 1.9

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

Julia 1.10

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

source
Base.invokelatestFunction
invokelatest(f, args...; kwargs...)

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

Julia 1.9

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

source
Base.@invokelatestMacro
@invokelatest f(args...; kwargs...)

invokelatestを呼び出すための便利な方法を提供します。@invokelatest f(args...; kwargs...)は単にBase.invokelatest(f, args...; kwargs...)に展開されます。

以下の構文もサポートしています:

  • @invokelatest x.fBase.invokelatest(getproperty, x, :f)に展開されます
  • @invokelatest x.f = vBase.invokelatest(setproperty!, x, :f, v)に展開されます
  • @invokelatest xs[i]Base.invokelatest(getindex, xs, i)に展開されます
  • @invokelatest xs[i] = vBase.invokelatest(setindex!, xs, v, i)に展開されます
julia> @macroexpand @invokelatest f(x; kw=kwv)
:(Base.invokelatest(f, x; kw = kwv))

julia> @macroexpand @invokelatest x.f
:(Base.invokelatest(Base.getproperty, x, :f))

julia> @macroexpand @invokelatest x.f = v
:(Base.invokelatest(Base.setproperty!, x, :f, v))

julia> @macroexpand @invokelatest xs[i]
:(Base.invokelatest(Base.getindex, xs, i))

julia> @macroexpand @invokelatest xs[i] = v
:(Base.invokelatest(Base.setindex!, xs, v, i))
Julia 1.7

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

Julia 1.9

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

Julia 1.10

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

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

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

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

引数 x に関数 f を適用する中置演算子です。これにより f(g(x))x |> g |> f と書くことができます。無名関数と一緒に使用する場合、意図したチェーンを得るために定義の周りに通常は括弧が必要です。

julia> 4 |> inv
0.25

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

julia> [0 1; 2 3] .|> (x -> x^2) |> sum
14
source
Base.:∘Function
f ∘ g

関数の合成: すなわち、(f ∘ g)(args...; kwargs...)f(g(args...; kwargs...)) を意味します。 シンボルは、Julia REPL(および適切に設定されたほとんどのエディタ)で \circ<tab> と入力することで入力できます。

関数の合成はプレフィックス形式でも機能します: ∘(f, g)f ∘ g と同じです。プレフィックス形式は複数の関数の合成をサポートします: ∘(f, g, h) = f ∘ g ∘ h およびスプラッティング ∘(fs...) は関数の反復可能なコレクションを合成します。 の最後の引数は最初に実行されます。

Julia 1.4

複数の関数の合成には少なくとも Julia 1.4 が必要です。

Julia 1.5

一つの関数の合成 ∘(f) には少なくとも Julia 1.5 が必要です。

Julia 1.7

キーワード引数の使用には少なくとも Julia 1.7 が必要です。

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

julia> (==(6)∘length).(["apple", "banana", "carrot"])
3-element BitVector:
 0
 1
 1

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

julia> ∘(fs...)(3)
2.0

さらに詳しくは ComposedFunction!f::Function を参照してください。

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

二つの呼び出し可能なオブジェクト outer::Outerinner::Inner の合成を表します。すなわち

ComposedFunction(outer, inner)(args...; kw...) === outer(inner(args...; kw...))

ComposedFunction のインスタンスを構築するための推奨される方法は、合成演算子 を使用することです:

julia> sin ∘ cos === ComposedFunction(sin, cos)
true

julia> typeof(sin∘cos)
ComposedFunction{typeof(sin), typeof(cos)}

合成された部分は ComposedFunction のフィールドに格納され、次のように取得できます:

julia> composition = sin ∘ cos
sin ∘ cos

julia> composition.outer === sin
true

julia> composition.inner === cos
true
Julia 1.6

ComposedFunction は少なくとも Julia 1.6 を必要とします。以前のバージョンでは は匿名関数を返します。

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

source
Base.splatFunction
splat(f)

は次のように等価です。

    my_splat(f) = args->f(args...)

すなわち、関数を与えると、新しい関数を返し、それは1つの引数を取り、それを元の関数にスプラットします。これは、複数の引数を持つ関数を、単一の引数を期待するコンテキストに渡すためのアダプタとして便利ですが、その単一の引数としてタプルを渡します。

julia> map(splat(+), zip(1:3,4:6))
3-element Vector{Int64}:
 5
 7
 9

julia> my_add = splat(+)
splat(+)

julia> my_add((1,2,3))
6
source
Base.Fix1Type
Fix1(f, x)

2つの引数を持つ関数 f の部分適用バージョンを表す型で、最初の引数が値 "x" に固定されています。言い換えれば、Fix1(f, x)y->f(x, y) と同様に動作します。

関連項目として Fix2 を参照してください。

source
Base.Fix2Type
Fix2(f, x)

2引数関数 f の部分適用バージョンを表す型で、2番目の引数が値 "x" に固定されています。言い換えれば、Fix2(f, x)y->f(y, x) と同様に動作します。

source

Syntax

Core.evalFunction
Core.eval(m::Module, expr)

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

source
evalFunction
eval(expr)

モジュールのグローバルスコープで式を評価します。すべての Modulebaremodule で定義されたものを除く)は、そのモジュール内で式を評価する1引数の eval 定義を持っています。

source
Base.@evalMacro
@eval [mod,] ex

evalを使用して、値を補間した式を評価します。2つの引数が提供される場合、最初の引数は評価するモジュールです。

source
Base.evalfileFunction
evalfile(path::AbstractString, args::Vector{String}=String[])

ファイルを匿名モジュールに読み込み、includeを使用してすべての式を評価し、最後の式の値を返します。オプションのargs引数は、スクリプトの入力引数(すなわち、グローバルARGS変数)を設定するために使用できます。定義(例えば、メソッドやグローバル変数)は匿名モジュール内で評価され、現在のモジュールには影響を与えないことに注意してください。

julia> write("testfile.jl", """
           @show ARGS
           1 + 1
       """);

julia> x = evalfile("testfile.jl", ["ARG1", "ARG2"]);
ARGS = ["ARG1", "ARG2"]

julia> x
2

julia> rm("testfile.jl")
source
Base.escFunction
esc(e)

マクロから返されたExprのコンテキスト内でのみ有効です。マクロの衛生パスが埋め込まれた変数をgensym変数に変換するのを防ぎます。詳細と例については、マニュアルのメタプログラミング章のマクロセクションを参照してください。

source
Base.@inboundsMacro
@inbounds(blk)

式内での配列の境界チェックを排除します。

以下の例では、配列 A の要素 i を参照するための範囲内チェックがスキップされ、パフォーマンスが向上します。

function sum(A::AbstractArray)
    r = zero(eltype(A))
    for i in eachindex(A)
        @inbounds r += A[i]
    end
    return r
end
Warning

@inbounds を使用すると、範囲外のインデックスに対して不正な結果/クラッシュ/破損が返される可能性があります。ユーザーは手動でチェックする責任があります。すべてのアクセスが境界内であることがローカルに利用可能な情報から確実である場合にのみ @inbounds を使用してください。特に、上記のような関数で eachindex(A) の代わりに 1:length(A) を使用することは、AbstractArray をサブタイプ化するすべてのユーザー定義型に対して A の最初のインデックスが 1 でない可能性があるため、安全に境界内とは言えません。

source
Base.@boundscheckMacro
@boundscheck(blk)

blk を境界チェックブロックとして注釈し、@inbounds によって省略されることを許可します。

Note

@boundscheck が書かれている関数は、その呼び出し元にインライン化される必要があり、そうでないと @inbounds は効果を持ちません。

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

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

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

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

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

@boundscheck 注釈は、ライブラリ作成者として、他のコード@inbounds を使用してあなたの境界チェックを削除することを許可するためのオプトインを可能にします。そこに記載されているように、呼び出し元は、@inbounds を使用する前に、自分がアクセスするインデックスが有効であることを確認する必要があります。たとえば、あなたの AbstractArray サブクラスへのインデックス付けでは、インデックスをその axes と照らし合わせて確認する必要があります。したがって、@boundscheck 注釈は、その動作が正しいことが確実である場合にのみ、getindex または setindex! の実装に追加されるべきです。

source
Base.@propagate_inboundsMacro
@propagate_inbounds

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

source
Base.@inlineMacro
@inline

コンパイラにこの関数をインライン化する価値があることを示します。

小さな関数には通常、@inline アノテーションは必要ありません。コンパイラが自動的に処理します。大きな関数に @inline を使用することで、コンパイラにインライン化を促すことができます。

@inline は関数定義の直前または関数本体内で適用できます。

# 長い定義にアノテーションを付ける
@inline function longdef(x)
    ...
end

# 短い定義にアノテーションを付ける
@inline shortdef(x) = ...

# `do` ブロックが作成する無名関数にアノテーションを付ける
f() do
    @inline
    ...
end
Julia 1.8

関数本体内での使用は、少なくとも Julia 1.8 が必要です。


@inline block

block 内の呼び出しがインライン化する価値があることをコンパイラに示します。

# コンパイラは `f` をインライン化しようとします
@inline f(...)

# コンパイラは `f`、`g` および `+` をインライン化しようとします
@inline f(...) + g(...)
Note

呼び出し元のアノテーションは、呼び出された関数の定義に適用されたアノテーションよりも常に優先されます:

@noinline function explicit_noinline(args...)
    # 本体
end

let
    @inline explicit_noinline(args...) # これはインライン化されます
end
Note

ネストされた呼び出し元のアノテーションがある場合、最も内側のアノテーションが優先されます:

@noinline let a0, b0 = ...
    a = @inline f(a0)  # コンパイラはこの呼び出しをインライン化しようとします
    b = f(b0)          # コンパイラはこの呼び出しをインライン化しようとはしません
    return a, b
end
Warning

呼び出し元のアノテーションはコストモデルに関係なくインライン化を強制しようとしますが、成功しない可能性もあります。特に、再帰呼び出しは @inline としてアノテーションされていてもインライン化できません。

Julia 1.8

呼び出し元のアノテーションは、少なくとも Julia 1.8 が必要です。

source
Base.@noinlineMacro
@noinline

コンパイラに関数をインライン化しないようにヒントを与えます。

小さな関数は通常自動的にインライン化されます。小さな関数に@noinlineを使用することで、自動インライン化を防ぐことができます。

@noinlineは関数定義の直前または関数本体内で適用できます。

# 長い形式の定義に注釈を付ける
@noinline function longdef(x)
    ...
end

# 短い形式の定義に注釈を付ける
@noinline shortdef(x) = ...

# `do`ブロックが作成する無名関数に注釈を付ける
f() do
    @noinline
    ...
end
Julia 1.8

関数本体内での使用は少なくともJulia 1.8が必要です。


@noinline block

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

# コンパイラは`f`をインライン化しないように試みます
@noinline f(...)

# コンパイラは`f`、`g`、および`+`をインライン化しないように試みます
@noinline f(...) + g(...)
Note

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

@inline function explicit_inline(args...)
    # 本体
end

let
    @noinline explicit_inline(args...) # インライン化されません
end
Note

ネストされた呼び出しサイトの注釈がある場合、最も内側の注釈が優先されます:

@inline let a0, b0 = ...
    a = @noinline f(a0)  # コンパイラはこの呼び出しをインライン化しようとしません
    b = f(b0)            # コンパイラはこの呼び出しをインライン化しようとします
    return a, b
end
Julia 1.8

呼び出しサイトの注釈は少なくともJulia 1.8が必要です。


Note

関数が単純(例えば定数を返す)である場合、インライン化される可能性があります。

source
Base.@nospecializeMacro
@nospecialize

関数引数名に適用されると、コンパイラに対してその引数の異なる型に対してメソッド実装を特化させず、代わりにその引数の宣言された型を使用するようにヒントを与えます。これは、形式的な引数リスト内の引数や関数本体内の引数に適用できます。引数に適用されるとき、マクロは引数の全体の式をラップする必要があります。例えば、@nospecialize(x::Real)@nospecialize(i::Integer...)のように、引数名だけをラップするのではありません。関数本体で使用される場合、マクロは文の位置にあり、任意のコードの前に出現する必要があります。

引数なしで使用されると、親スコープのすべての引数に適用されます。ローカルスコープでは、これは含まれている関数のすべての引数を意味します。グローバル(トップレベル)スコープでは、これは現在のモジュールでその後に定義されるすべてのメソッドを意味します。

特化は、@specializeを使用することでデフォルトにリセットできます。

function example_function(@nospecialize x)
    ...
end

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

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

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

@nospecializeはコード生成に影響を与えますが、推論には影響を与えません:生成されるネイティブコードの多様性を制限しますが、型推論に対しては(標準的な制限を超えて)制限を課しません。推論を追加で抑制するために、@nospecializeと一緒にBase.@nospecializeinferを使用してください。

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Float64
└──      return %1
) => Float64

ここで、@nospecialize注釈は次のように等価になります。

f(A::AbstractArray) = invoke(g, Tuple{AbstractArray}, A)

これにより、gのためにネイティブコードの1つのバージョンのみが生成されることが保証され、任意のAbstractArrayに対して一般的なものになります。しかし、特定の戻り値の型は、gfの両方に対して依然として推論され、これはfgの呼び出し元の最適化に使用されます。

source
Base.@specializeMacro
@specialize

引数の特化ヒントをデフォルトにリセットします。詳細については、@nospecializeを参照してください。

source
Base.@nospecializeinferMacro
Base.@nospecializeinfer function f(args...)
    @nospecialize ...
    ...
end
Base.@nospecializeinfer f(@nospecialize args...) = ...

コンパイラに@nospecializeされた引数の宣言された型を使用してfを推論するよう指示します。これは、推論中にコンパイラ生成の特化の数を制限するために使用できます。

julia> f(A::AbstractArray) = g(A)
f (generic function with 1 method)

julia> @noinline Base.@nospecializeinfer g(@nospecialize(A::AbstractArray)) = A[1]
g (generic function with 1 method)

julia> @code_typed f([1.0])
CodeInfo(
1 ─ %1 = invoke Main.g(_2::AbstractArray)::Any
└──      return %1
) => Any

この例では、fAの各特定の型に対して推論されますが、gは宣言された引数型A::AbstractArrayで一度だけ推論されるため、コンパイラはそれに対して過剰な推論時間を見ない可能性が高く、具体的な戻り値の型を推論できません。@nospecializeinferがなければ、f([1.0])gの戻り値の型をFloat64として推論し、特化コード生成が禁止されているにもかかわらずg(::Vector{Float64})のために推論が実行されたことを示します。

Julia 1.10

Base.@nospecializeinferを使用するには、Juliaバージョン1.10が必要です。

```

source
Base.@constpropMacro
Base.@constprop 設定 [ex]

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

2つの setting がサポートされています:

  • Base.@constprop :aggressive [ex]: 定数伝播を積極的に適用します。戻り値の型が引数の値に依存するメソッドの場合、これは追加のコンパイル時間のコストで推論結果を改善する可能性があります。
  • Base.@constprop :none [ex]: 定数伝播を無効にします。これにより、Juliaが定数伝播に値すると思われる関数のコンパイル時間を短縮できます。一般的なケースは、Bool または Symbol 値の引数やキーワード引数を持つ関数です。

Base.@constprop は、関数定義の直前または関数本体内で適用できます。

# 長形式の定義に注釈を付ける
Base.@constprop :aggressive function longdef(x)
    ...
end

# 短形式の定義に注釈を付ける
Base.@constprop :aggressive shortdef(x) = ...

# `do` ブロックが作成する無名関数に注釈を付ける
f() do
    Base.@constprop :aggressive
    ...
end
Julia 1.10

関数本体内での使用は、少なくとも Julia 1.10 が必要です。

source
Base.gensymFunction
gensym([tag])

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

source
Base.@gensymMacro
@gensym

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

source
var"name"Keyword
var

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

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

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

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

Julia 1.3

この構文は少なくともJulia 1.3が必要です。

source
Base.@gotoMacro
@goto name

@goto name は、@label name の位置にあるステートメントに無条件でジャンプします。

@label@goto は、異なるトップレベルのステートメントへのジャンプを作成することはできません。試みるとエラーが発生します。@goto を使用するには、@label@goto をブロック内に囲む必要があります。

source
Base.@labelMacro
@label name

シンボリックラベル name でステートメントにラベルを付けます。このラベルは、@goto name による無条件ジャンプの終点を示します。

source
Base.SimdLoop.@simdMacro
@simd

@simdを使用して、コンパイラがループの再配置を許可するためにforループに注釈を付けます。

Warning

この機能は実験的であり、将来のJuliaのバージョンで変更されたり消失したりする可能性があります。@simdマクロの不適切な使用は予期しない結果を引き起こす可能性があります。

@simd forループで反復されるオブジェクトは、一次元の範囲である必要があります。@simdを使用することで、ループのいくつかの特性を主張しています:

  • 繰り返しを任意または重複した順序で実行することが安全であり、特に還元変数に関して考慮されます。
  • 還元変数に対する浮動小数点演算は再配置または収束される可能性があり、@simdなしでの結果とは異なる結果を引き起こす可能性があります。

多くの場合、Juliaは@simdを使用せずに内部のforループを自動的にベクトル化することができます。@simdを使用することで、コンパイラはより多くの状況でそれを可能にするための少し余裕を持つことができます。いずれの場合でも、内部ループはベクトル化を許可するために以下の特性を持っている必要があります:

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

@simdはデフォルトでループが完全にループ運搬メモリ依存性から自由であることを主張しません。これは一般的なコードでは簡単に違反される仮定です。非一般的なコードを書いている場合は、@simd ivdep for ... endを使用して、以下も主張できます:

  • ループ運搬メモリ依存性は存在しない
  • どの反復も前の反復が前進するのを待つことはありません。
source
Base.@pollyMacro
@polly

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

source
Base.@generatedMacro
@generated f

@generated は生成される関数に注釈を付けるために使用されます。生成された関数の本体では、引数の値ではなく、引数の型のみを読み取ることができます。この関数は、関数が呼び出されたときに評価される引用された式を返します。@generated マクロは、グローバルスコープを変更する関数や可変要素に依存する関数には使用すべきではありません。

詳細については Metaprogramming を参照してください。

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

julia> bar(4)
16

julia> bar("baz")
"baz"
source
Base.@assume_effectsMacro
Base.@assume_effects 設定... [ex]

コンパイラの効果モデリングをオーバーライドします。このマクロは、いくつかのコンテキストで使用できます。

  1. メソッド定義の直前に、適用されたメソッドの全体的な効果モデリングをオーバーライドするために。
  2. 引数なしの関数本体内で、囲まれたメソッドの全体的な効果モデリングをオーバーライドするために。
  3. コードブロックに適用して、適用されたコードブロックのローカルな効果モデリングをオーバーライドするために。

julia> Base.@assume_effects :terminates_locally function fact(x)
           # 使用例 1:
           # この :terminates_locally により `fact` は定数折りたたみが可能になる
           res = 1
           0 ≤ x < 20 || error("bad fact")
           while x > 1
               res *= x
               x -= 1
           end
           return res
       end
fact (generic function with 1 method)

julia> code_typed() do
           fact(12)
       end |> only
CodeInfo(
1 ─     return 479001600
) => Int64

julia> code_typed() do
           map((2,3,4)) do x
               # 使用例 2:
               # この :terminates_locally によりこの無名関数は定数折りたたみが可能になる
               Base.@assume_effects :terminates_locally
               res = 1
               0 ≤ x < 20 || error("bad fact")
               while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}

julia> code_typed() do
           map((2,3,4)) do x
               res = 1
               0 ≤ x < 20 || error("bad fact")
               # 使用例 3:
               # この :terminates_locally アノテーションによりコンパイラは汚染をスキップする
               # この `while` ブロック内の `:terminates` 効果を許可し、親
               # 無名関数が定数折りたたみされることを可能にする
               Base.@assume_effects :terminates_locally while x > 1
                   res *= x
                   x -= 1
               end
               return res
           end
       end |> only
CodeInfo(
1 ─     return (2, 6, 24)
) => Tuple{Int64, Int64, Int64}
Julia 1.8

Base.@assume_effects を使用するには、Julia バージョン 1.8 が必要です。

Julia 1.10

関数本体内での使用には少なくとも Julia 1.10 が必要です。

Julia 1.11

コードブロックのアノテーションには少なくとも Julia 1.11 が必要です。

Warning

このマクロの不適切な使用は未定義の動作を引き起こす可能性があります(クラッシュ、不正確な回答、または追跡が困難なバグを含む)。注意して使用し、絶対に必要な場合にのみ最後の手段として使用してください。そのような場合でも、効果の主張の強さを最小限に抑えるために可能な限りの手段を講じるべきです(例::nothrow が十分であった場合は :total を使用しない)。

一般に、各 setting 値は関数の動作に関する主張を行い、コンパイラがこの動作が実際に真であることを証明する必要はありません。これらの主張はすべてのワールドエイジに対して行われます。したがって、後で拡張されて仮定を無効にする可能性のある汎用関数の使用を制限することが推奨されます(これにより未定義の動作が引き起こされる可能性があります)。

以下の setting がサポートされています。

  • :consistent
  • :effect_free
  • :nothrow
  • :terminates_globally
  • :terminates_locally
  • :notaskstate
  • :inaccessiblememonly
  • :noub
  • :noub_if_noinbounds
  • :nortcall
  • :foldable
  • :removable
  • :total

拡張ヘルプ


:consistent

:consistent 設定は、等しい (===) 入力に対して次のことを主張します:

  • 終了の方法(戻り値、例外、非終了)は常に同じである。
  • メソッドが戻る場合、結果は常に等しい。
Note

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

Note

:consistent-cy の主張はワールドエイジごとに行われます。より正式には、$fᵢ$ をワールドエイジ $i$ における $f$ の評価と書くと、この設定は次のことを要求します:

\[∀ i, x, y: x ≡ y → fᵢ(x) ≡ fᵢ(y)\]

ただし、ワールドエイジ $i$$j$ に対して $i ≠ j$ の場合、$fᵢ(x) ≢ fⱼ(y)$ である可能性があります。

さらに、:consistent 関数は、特定のワールドエイジに対して一定でないグローバル状態やヒープの状態に依存して戻り値を決定してはなりません。

Note

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

Note

:consistent 関数が例外をスローして終了する場合、その例外自体は上記の等価性要件を満たす必要はありません。


:effect_free

:effect_free 設定は、メソッドが外部的に意味的に可視な副作用がないことを主張します。以下は外部的に意味的に可視な副作用の不完全なリストです:

  • グローバル変数の値を変更すること。
  • ヒープを変更すること(例:配列や可変値)、ただし以下に記載されている場合を除く。
  • メソッドテーブルを変更すること(例:eval への呼び出しを通じて)。
  • ファイル/ネットワーク/etc. I/O。
  • タスクの切り替え。

ただし、以下は明示的に意味的に可視ではありませんが、観察可能である場合があります:

  • メモリの割り当て(可変および不変の両方)。
  • 経過時間。
  • ガーベジコレクション。
  • メソッドのライフタイムを超えないオブジェクトのヒープの変更(すなわち、メソッド内で割り当てられ、エスケープしないもの)。
  • 戻り値(外部的に可視ですが、副作用ではありません)。

ここでのルールは、外部的に可視な副作用は、関数が実行されなかった場合にプログラムの残りの部分の実行に影響を与えるものです。

Note

:effect_free の主張は、メソッド自体とメソッドによって実行されるコードの両方に対して行われます。この主張はすべてのワールドエイジに対して有効でなければならず、それに応じてこの主張の使用を制限する必要があります。


:nothrow

:nothrow 設定は、このメソッドが例外をスローしないことを主張します(すなわち、常に値を返すか、決して戻らないことを意味します)。

Note

:nothrow アノテーションが付けられたメソッドが内部で例外処理を使用することは許可されますが、例外がメソッド自体から再スローされることはありません。

Note

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


:terminates_globally

:terminates_globally 設定は、このメソッドが最終的に終了すること(通常または異常に)、すなわち無限ループに陥らないことを主張します。

Note

この :terminates_globally の主張は、アノテーションされたメソッドによって呼び出される他のメソッドをカバーします。

Note

コンパイラは、メソッドが比較的迅速に終了することを示す強い指標と見なします。したがって、技術的には終了するが実際には終了しないメソッドにこの設定をアノテートするのは良くありません。


:terminates_locally

:terminates_locally 設定は :terminates_globally と似ていますが、アノテーションされたメソッド内の構文的制御フローにのみ適用されます。したがって、メソッドが他のメソッドを呼び出して終了しない可能性がある場合、これははるかに弱い(したがって安全な)主張です。

Note

:terminates_globally:terminates_locally を含意します。


:notaskstate

:notaskstate 設定は、メソッドがローカルタスク状態(タスクローカルストレージ、RNG状態など)を使用または変更しないことを主張し、したがってタスク間で安全に移動できることを示します。

Note

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

Note

:notaskstate の主張は、現在実行中のタスク の状態に関するものです。現在実行中のタスクを考慮しない他の手段によって Task オブジェクトへの参照が取得された場合、:notaskstate 効果は汚染される必要はありません。これは、該当するタスクオブジェクトが現在実行中のタスクと === である場合でも当てはまります。

Note

タスク状態へのアクセスは、通常、他の効果の汚染も引き起こします。たとえば、タスク状態が変更された場合は :effect_free(またはタスク状態が結果の計算に使用された場合は :consistent)が汚染される可能性があります。特に、:notaskstate ではないが、:effect_free および :consistent であるコードは、デッドコード削除され、したがって :total に昇格される可能性があります。


:inaccessiblememonly

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

Note

以下は、この仮定を無効にする不完全なリストの例です:

  • 可変グローバル変数にアクセスするためのグローバル参照または getglobal 呼び出し
  • 非定数のグローバル変数に代入を行うためのグローバル代入または setglobal! 呼び出し
  • グローバル可変変数のフィールドを変更する setfield! 呼び出し
Note

この :inaccessiblememonly の主張は、アノテーションされたメソッドによって呼び出される他のメソッドをカバーします。


:noub

:noub 設定は、メソッドが未定義の動作を実行しないことを主張します(任意の入力に対して)。未定義の動作は、技術的にはメソッドが他の効果の主張(たとえば :consistent:effect_free)を違反する原因となる可能性がありますが、これをモデル化せず、未定義の動作が存在しないことを前提とします。


:nortcall

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

Note

正確には、この主張は Core.Compiler.return_type への呼び出しが実行時に行われない場合に使用できます。すなわち、Core.Compiler.return_type の結果がコンパイル時に正確に知られており、呼び出しがオプティマイザによって排除される場合です。ただし、Core.Compiler.return_type の結果がコンパイル時に折りたたまれるかどうかは、コンパイラの実装に大きく依存するため、該当するメソッドが Core.Compiler.return_type を何らかの形で使用している場合、これを主張するのは一般的にリスクがあります。


:foldable

この設定は、コンパイラがコンパイル時に呼び出しを定数折りたたみすることを保証するために必要な効果のセットの便利なショートカットです。現在、次の setting と同等です:

  • :consistent
  • :effect_free
  • :terminates_globally
  • :noub
  • :nortcall
Note

このリストには特に :nothrow は含まれていません。コンパイラは依然として定数伝播を試み、コンパイル時にスローされたエラーを記録します。ただし、:consistent-cy の要件により、そのようにアノテートされた呼び出しは、同じ引数値に対して一貫してスローされる必要があります。

Note

関数内の明示的な @inbounds アノテーションも定数折りたたみを無効にし、:foldable によって上書きされることはありません。


:removable

この設定は、コンパイラがコンパイル時に結果が未使用の呼び出しを削除することを保証するために必要な効果のセットの便利なショートカットです。現在、次の setting と同等です:

  • :effect_free
  • :nothrow
  • :terminates_globally

:total

この setting は、可能な最大の効果のセットです。現在、次の他の setting を含意します:

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

:total は非常に強い主張であり、将来の Julia のバージョンで追加の意味を持つ可能性があります(たとえば、追加の効果が追加され、:total の定義に含まれる場合)。その結果、注意して使用する必要があります。可能な限り、特定のアプリケーションに必要な最小限の特定の効果の主張を使用することをお勧めします。多くの効果のオーバーライドが関数のセットに適用される場合、:total の使用よりもカスタムマクロを使用することが推奨されます。


否定された効果

効果名は ! で接頭辞を付けることができ、以前のメタ効果から効果を削除することを示します。たとえば、:total !:nothrow は、呼び出しが一般的にはトータルであるが、スローする可能性があることを示します。 ```

source

Managing deprecations

Base.@deprecateMacro
@deprecate old new [export_old=true]

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

old をエクスポートしないようにするには、export_oldfalse に設定します。

詳細は Base.depwarn() を参照してください。

Julia 1.5

Julia 1.5 以降、@deprecate で定義された関数は、--depwarn=yes フラグが設定されていない場合に警告を表示しません。デフォルトの --depwarn オプションの値は no です。警告は 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)

明示的な型アノテーションなしでの @deprecate への呼び出しは、任意の数の位置引数およびキーワード引数を Any 型で受け入れる非推奨メソッドを定義します。

Julia 1.9

明示的な型アノテーションがない場合、キーワード引数は Julia 1.9 以降に転送されます。古いバージョンでは、@deprecate old(args...; kwargs...) new(args...; kwargs...) を行うことで、位置引数とキーワード引数を手動で転送できます。

特定のシグネチャに非推奨を制限するには、old の引数にアノテーションを付けます。例えば、

julia> new(x::Int) = x;

julia> new(x::Float64) = 2x;

julia> @deprecate old(x::Int) new(x);

julia> methods(old)
# 1 method for generic function "old" from Main:
 [1] old(x::Int64)
     @ deprecated.jl:94

これは、new(x::Int) を反映する old(x::Int) というメソッドを定義し、old(x::Float64) メソッドは定義も非推奨にもなりません。

source
Base.depwarnFunction
Base.depwarn(msg::String, funcsym::Symbol; force=false)

msgを非推奨警告として印刷します。シンボルfuncsymは呼び出し関数の名前であり、各呼び出し場所に対して非推奨警告が最初にのみ印刷されることを保証するために使用されます。force=trueを設定すると、Juliaが--depwarn=no(デフォルト)で起動されていても、警告が常に表示されるようになります。

詳細は@deprecateを参照してください。

function deprecated_func()
    Base.depwarn("Don't use `deprecated_func()`!", :deprecated_func)

    1 + 1
end
source

Missing Values

Base.coalesceFunction
coalesce(x...)

引数の中で missing でない最初の値を返します。もしそのような値がなければ、missing を返します。

他にも skipmissingsomething@coalesce を参照してください。

julia> coalesce(missing, 1)
1

julia> coalesce(1, missing)
1

julia> coalesce(nothing, 1)  # `nothing` を返します

julia> coalesce(missing, missing)
missing
source
Base.@coalesceMacro
@coalesce(x...)

短絡評価バージョンの coalesce

julia> f(x) = (println("f($x)"); missing);

julia> a = 1;

julia> a = @coalesce a f(2) f(3) error("`a` はまだ missing です")
1

julia> b = missing;

julia> b = @coalesce b f(2) f(3) error("`b` はまだ missing です")
f(2)
f(3)
ERROR: `b` はまだ missing です
[...]
Julia 1.7

このマクロは Julia 1.7 以降で利用可能です。

source
Base.skipmissingFunction
skipmissing(itr)

itr内の要素を反復処理し、missing値をスキップするイテレータを返します。返されるオブジェクトは、itrがインデックス可能であれば、itrのインデックスを使用してインデックス付けできます。欠損値に対応するインデックスは無効であり、keysおよびeachindexによってスキップされ、使用しようとするとMissingExceptionがスローされます。

collectを使用して、itr内の非missing値を含むArrayを取得します。itrが多次元配列であっても、入力の次元を保持しながら欠損を削除することは不可能なため、結果は常にVectorになります。

他にもcoalesceismissingsomethingがあります。

julia> x = skipmissing([1, missing, 2])
skipmissing(Union{Missing, Int64}[1, missing, 2])

julia> sum(x)
3

julia> x[1]
1

julia> x[2]
ERROR: MissingException: the value at index (2,) is missing
[...]

julia> argmax(x)
3

julia> collect(keys(x))
2-element Vector{Int64}:
 1
 3

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

julia> collect(skipmissing([1 missing; 2 missing]))
2-element Vector{Int64}:
 1
 2
source
Base.nonmissingtypeFunction
nonmissingtype(T::Type)

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

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

julia> nonmissingtype(Any)
Any
Julia 1.3

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

source

System

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

バッククォートで構築されたコマンドオブジェクトを実行します(マニュアルの外部プログラムの実行セクションを参照)。プロセスが非ゼロのステータスで終了するなど、何か問題が発生した場合はエラーをスローします(waitがtrueの場合)。

args...を使用すると、コマンドにファイルディスクリプタを渡すことができ、通常のunixファイルディスクリプタ(例:stdin, stdout, stderr, FD(3), FD(4)...)のように順序付けられます。

waitがfalseの場合、プロセスは非同期で実行されます。後でそれを待機し、返されたプロセスオブジェクトでsuccessを呼び出すことでその終了ステータスを確認できます。

waitがfalseの場合、プロセスのI/Oストリームはdevnullに向けられます。waitがtrueの場合、I/Oストリームは親プロセスと共有されます。I/Oリダイレクションを制御するにはpipelineを使用してください。

source
Base.devnullConstant
devnull

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

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

バックティックで構築されたコマンドオブジェクトを実行し(マニュアルの外部プログラムの実行セクションを参照)、成功したかどうか(コード0で終了したか)を知らせます。プロセスを開始できない場合は例外が発生します。

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

プロセスにシグナルを送信します。デフォルトはプロセスを終了させることです。プロセスがすでに終了している場合は成功を返しますが、プロセスの終了に失敗した場合(例:権限不足)にはエラーをスローします。

source
Base.Sys.set_process_titleFunction
Sys.set_process_title(title::AbstractString)

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

source
Base.Sys.get_process_titleFunction
Sys.get_process_title()

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

source
Base.ignorestatusFunction
ignorestatus(command)

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

source
Base.detachFunction
detach(command)

コマンドオブジェクトにマークを付けて、新しいプロセスグループで実行されるようにし、juliaプロセスを超えて生存できるようにし、Ctrl-Cの割り込みがそれに渡されないようにします。

source
Base.CmdType
Cmd(cmd::Cmd; ignorestatus, detach, windows_verbatim, windows_hide, env, dir)
Cmd(exec::Vector{String})

新しい Cmd オブジェクトを構築し、cmd から外部プログラムと引数を表現し、オプションのキーワード引数の設定を変更します:

  • ignorestatus::Bool: true の場合(デフォルトは false)、Cmd は戻りコードがゼロ以外の場合にエラーをスローしません。
  • detach::Bool: true の場合(デフォルトは false)、Cmd は新しいプロセスグループで実行され、julia プロセスよりも長生きし、Ctrl-C が渡されないようになります。
  • windows_verbatim::Bool: true の場合(デフォルトは false)、Windows では Cmd が引数を引用符やエスケープなしでプロセスにコマンドライン文字列を送信します。スペースを含む引数も含まれます。(Windows では、引数は単一の「コマンドライン」文字列としてプログラムに送信され、プログラムはそれを引数に解析する責任があります。デフォルトでは、空の引数やスペースまたはタブを含む引数はコマンドラインで二重引用符 " で引用され、\ または " はバックスラッシュで前置されます。windows_verbatim=true は、非標準的な方法でコマンドラインを解析するプログラムを起動するのに便利です。)非Windowsシステムには影響しません。
  • windows_hide::Bool: true の場合(デフォルトは false)、Windows では Cmd が実行されるときに新しいコンソールウィンドウは表示されません。すでにコンソールが開いている場合や非Windowsシステムでは影響しません。
  • env: Cmd を実行する際に使用する環境変数を設定します。env は文字列を文字列にマッピングする辞書、形式が "var=val" の文字列の配列、または "var"=>val ペアの配列またはタプルのいずれかです。既存の環境を変更(置き換えではなく)するには、envcopy(ENV) で初期化し、必要に応じて env["var"]=val を設定します。すべての要素を置き換えずに Cmd オブジェクト内の環境ブロックに追加するには、addenv() を使用し、更新された環境を持つ Cmd オブジェクトを返します。
  • dir::AbstractString: コマンドの作業ディレクトリを指定します(現在のディレクトリの代わりに)。

指定されていないキーワードについては、cmd からの現在の設定が使用されます。

Cmd(exec) コンストラクタは exec のコピーを作成しないことに注意してください。exec に対するその後の変更は Cmd オブジェクトに反映されます。

Cmd オブジェクトを構築する最も一般的な方法は、コマンドリテラル(バックティック)を使用することです。例えば:

`ls -l`

これを Cmd コンストラクタに渡して設定を変更することができます。例えば:

Cmd(`echo "Hello world"`, ignorestatus=true, detach=false)
source
Base.setenvFunction
setenv(command::Cmd, env; dir)

指定された command を実行する際に使用する環境変数を設定します。env は、文字列を文字列にマッピングする辞書、"var=val" 形式の文字列の配列、またはゼロ個以上の "var"=>val ペア引数のいずれかです。既存の環境を変更(置き換えではなく)するには、copy(ENV) を通じて env を作成し、必要に応じて env["var"]=val を設定するか、addenv を使用します。

dir キーワード引数は、コマンドの作業ディレクトリを指定するために使用できます。dir は、指定されていない場合は command の現在設定されている dir(指定されていない場合は現在の作業ディレクトリ)にデフォルト設定されます。

他にも CmdaddenvENVpwd を参照してください。

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

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

他にも CmdsetenvENV を参照してください。

Julia 1.6

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

source
Base.withenvFunction
withenv(f, kv::Pair...)

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

Warning

環境を変更することはスレッドセーフではありません。親プロセスとは異なる環境で外部コマンドを実行する場合は、withenvの代わりにaddenvを使用することをお勧めします。

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

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

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

Julia 1.8

この関数は少なくともJulia 1.8が必要です。

Linuxでは、tasksetコマンドラインプログラムを使用してsetcpuaffinityの動作を確認できます。

julia> run(setcpuaffinity(`sh -c 'taskset -p $$'`, [1, 2, 5]));
pid 2273's current affinity mask: 13

マスク値13は、最下位の位置から数えて最初、第二、第五のビットがオンになっていることを反映しています:

julia> 0b010011
0x13
source
Base.pipelineMethod
pipeline(from, to, ...)

データソースから宛先へのパイプラインを作成します。ソースと宛先はコマンド、I/Oストリーム、文字列、または他のpipeline呼び出しの結果であることができます。少なくとも1つの引数はコマンドでなければなりません。文字列はファイル名を指します。2つ以上の引数で呼び出すと、左から右に連鎖します。例えば、pipeline(a,b,c)pipeline(pipeline(a,b),c)と同等です。これにより、マルチステージパイプラインをより簡潔に指定することができます。

:

run(pipeline(`ls`, `grep xyz`))
run(pipeline(`ls`, "out.txt"))
run(pipeline("out.txt", `grep xyz`))
source
Base.pipelineMethod
pipeline(command; stdin, stdout, stderr, append=false)

指定された command へのまたはからの I/O をリダイレクトします。キーワード引数は、リダイレクトすべきコマンドのストリームを指定します。append はファイル出力がファイルに追加されるかどうかを制御します。これは、2引数の pipeline 関数のより一般的なバージョンです。pipeline(from, to) は、from がコマンドの場合は pipeline(from, stdout=to) と同等であり、from が別の種類のデータソースの場合は pipeline(to, stdin=from) と同等です。

:

run(pipeline(`dothings`, stdout="out.txt", stderr="errs.txt"))
run(pipeline(`update`, stdout="log.txt", append=true))
source
Base.Libc.getpidFunction
getpid() -> Int32

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

source
getpid(process) -> Int32

子プロセスIDを取得します。プロセスがまだ存在する場合に限ります。

Julia 1.1

この関数は少なくともJulia 1.1が必要です。

source
Base.Libc.timeMethod
time() -> Float64

エポックからの秒数でシステム時間を取得します。解像度はかなり高く(通常はマイクロ秒)なっています。

source
Base.time_nsFunction
time_ns() -> UInt64

ナノ秒単位で時間を取得します。0に対応する時間は未定義で、5.8年ごとにラップします。

source
Base.@timeMacro
@time expr
@time "description" expr

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

オプションで、時間レポートの前に印刷する説明文字列を提供できます。

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

他に @showtime@timev@timed@elapsed@allocated、および @allocations も参照してください。

Note

より真剣なベンチマーキングには、ノイズを減らすために関数を複数回評価するなどの機能を持つ BenchmarkTools.jl パッケージの @btime マクロを検討してください。

Julia 1.8

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

コンパイル時間とは別に再コンパイル時間が表示されるようになったのは、Julia 1.8 で導入されました。

Julia 1.11

ロックの競合の報告は、Julia 1.11 で追加されました。

julia> x = rand(10,10);

julia> @time x * x;
  0.606588 秒 (2.19 M の割り当て: 116.555 MiB, 3.75% gc 時間, 99.94% コンパイル時間)

julia> @time x * x;
  0.000009 秒 (1 の割り当て: 896 バイト)

julia> @time begin
           sleep(0.3)
           1+1
       end
  0.301395 秒 (8 の割り当て: 336 バイト)
2

julia> @time "A one second sleep" sleep(1)
A one second sleep: 1.005750 秒 (5 の割り当て: 144 バイト)

julia> for loop in 1:3
            @time loop sleep(1)
        end
1: 1.006760 秒 (5 の割り当て: 144 バイト)
2: 1.001263 秒 (5 の割り当て: 144 バイト)
3: 1.003676 秒 (5 の割り当て: 144 バイト)
source
Base.@showtimeMacro
@showtime expr

@timeと似ていますが、参照のために評価されている式も印刷します。

Julia 1.8

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

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

julia> @showtime sleep(1)
sleep(1): 1.002164秒 (4回のアロケーション: 128バイト)
source
Base.@timevMacro
@timev expr
@timev "description" expr

これは@timeマクロの詳細版です。最初に@timeと同じ情報を印刷し、その後に非ゼロのメモリ割り当てカウンタを表示し、最後に式の値を返します。

オプションで、時間レポートの前に印刷する説明文字列を提供できます。

Julia 1.8

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

他に@time@timed@elapsed@allocated、および@allocationsを参照してください。

julia> x = rand(10,10);

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

julia> @timev x * x;
  0.000010 seconds (1 allocation: 896 bytes)
elapsed time (ns): 9848
bytes allocated:   896
pool allocs:       1
source
Base.@timedMacro
@timed

式を実行し、その式の値、経過時間(秒)、合計バイト数、ガベージコレクション時間、さまざまなメモリアロケーションカウンタを持つオブジェクト、コンパイル時間(秒)、および再コンパイル時間(秒)を返すマクロです。 ReentrantLock が待機しなければならなかったロックの競合は、カウントとして表示されます。

場合によっては、システムは @timed 式の内部を調べ、トップレベルの式の実行が始まる前に呼び出されたコードの一部をコンパイルします。その場合、一部のコンパイル時間はカウントされません。この時間を含めるには、@timed @eval ... を実行できます。

他に @time@timev@elapsed@allocated@allocations、および @lock_conflicts も参照してください。

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

julia> stats.time
0.006634834

julia> stats.bytes
8000256

julia> stats.gctime
0.0055765

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

julia> stats.gcstats.total_time
5576500

julia> stats.compile_time
0.0

julia> stats.recompile_time
0.0
Julia 1.5

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

Julia 1.11

lock_conflictscompile_time、および recompile_time フィールドは、Julia 1.11で追加されました。

source
Base.@elapsedMacro
@elapsed

式を評価し、結果の値を破棄し、実行にかかった秒数を浮動小数点数として返すマクロです。

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

他に @time@timev@timed@allocated、および @allocations も参照してください。

julia> @elapsed sleep(0.3)
0.301391426
source
Base.@allocatedMacro
@allocated

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

他に @allocations@time@timev@timed、および @elapsed も参照してください。

julia> @allocated rand(10^6)
8000080
source
Base.@allocationsMacro
@allocations

式を評価し、結果の値を破棄し、代わりに式の評価中に行われた合計のアロケーション数を返すマクロです。

他に @allocated@time@timev@timed、および @elapsed も参照してください。

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

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

source
Base.@lock_conflictsMacro
@lock_conflicts

式を評価し、結果の値を破棄し、代わりに評価中のロック競合の総数を返すマクロです。ここで、ReentrantLock に対するロック試行が、ロックがすでに保持されているために待機を引き起こしました。

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

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

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

source
Base.EnvDictType
EnvDict() -> EnvDict

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

source
Base.ENVConstant
ENV

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

(Windowsでは、システム環境変数は大文字と小文字を区別しないため、ENV はすべてのキーを表示、反復、コピーのために大文字に変換します。ポータブルなコードは、変数を大文字と小文字で区別できる能力に依存すべきではなく、表面的に小文字の変数を設定すると大文字の ENV キーになる可能性があることに注意する必要があります。)

Warning

環境を変更することはスレッドセーフではありません。

julia> ENV
Base.EnvDict with "50" entries:
  "SECURITYSESSIONID"            => "123"
  "USER"                         => "username"
  "MallocNanoZone"               => "0"
  ⋮                              => ⋮

julia> ENV["JULIA_EDITOR"] = "vim"
"vim"

julia> ENV["JULIA_EDITOR"]
"vim"

関連項目: withenv, addenv.

source
Base.Sys.STDLIBConstant
Sys.STDLIB::String

stdlib パッケージを含むディレクトリへのフルパスを含む文字列。

source
Base.Sys.isbsdFunction
Sys.isbsd([os])

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

Note

DarwinカーネルはBSDから派生しているため、macOSシステムではSys.isbsd()trueになります。述語からmacOSを除外するには、Sys.isbsd() && !Sys.isapple()を使用してください。

source
Base.Sys.isfreebsdFunction
Sys.isfreebsd([os])

FreeBSDの派生であるかどうかをテストするための述語です。詳細はOperating System Variationの取り扱いを参照してください。

Note

Sys.isbsd()と混同しないでください。これはFreeBSDではtrueですが、他のBSDベースのシステムでもtrueです。Sys.isfreebsd()はFreeBSDのみに関連しています。

Julia 1.1

この関数は少なくともJulia 1.1が必要です。

source
Base.Sys.isopenbsdFunction
Sys.isopenbsd([os])

OpenBSDの派生であるかどうかをテストするための述語。詳細はOperating System Variationの取り扱いを参照してください。

Note

Sys.isbsd()と混同しないでください。これはOpenBSDではtrueですが、他のBSDベースのシステムでもtrueです。Sys.isopenbsd()はOpenBSDのみに関連しています。

Julia 1.1

この関数は少なくともJulia 1.1が必要です。

source
Base.Sys.isnetbsdFunction
Sys.isnetbsd([os])

NetBSDの派生であるかどうかをテストするための述語。詳細はOperating System Variationの取り扱いを参照してください。

Note

Sys.isbsd()と混同しないでください。これはNetBSDではtrueですが、他のBSDベースのシステムでもtrueです。Sys.isnetbsd()はNetBSDのみに関連しています。

Julia 1.1

この関数は少なくともJulia 1.1が必要です。

source
Base.Sys.isdragonflyFunction
Sys.isdragonfly([os])

DragonFly BSDの派生であるかどうかをテストするための述語。詳細はOperating System Variationの取り扱いを参照してください。

Note

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

Julia 1.1

この関数は少なくともJulia 1.1が必要です。

source
Base.Sys.windows_versionFunction
Sys.windows_version()

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

source
Base.Sys.total_memoryFunction
Sys.total_memory()

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

source
Base.Sys.free_physical_memoryFunction
Sys.free_physical_memory()

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

source
Base.Sys.total_physical_memoryFunction
Sys.total_physical_memory()

RAMの合計メモリ(現在使用中のものを含む)をバイト単位で取得します。全体の量が現在のプロセスに利用可能であるとは限りません。Sys.total_memory()を参照してください。

source
Base.Sys.uptimeFunction
Sys.uptime()

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

source
Base.Sys.isjsvmFunction
Sys.isjsvm([os])

JuliaがJavaScript VM(JSVM)で実行されているかどうかをテストするための述語で、例えば、ウェブブラウザ内のWebAssembly JavaScript埋め込みを含みます。

Julia 1.2

この関数は少なくともJulia 1.2が必要です。

source
Base.Sys.loadavgFunction
Sys.loadavg()

負荷平均を取得します。参照: https://en.wikipedia.org/wiki/Load_(computing).

source
Base.Sys.isexecutableFunction
isexecutable(path::String)

与えられた path に実行可能な権限がある場合は true を返します。

Note

この権限はユーザーが path を実行する前に変更される可能性があるため、最初に isexecutable を呼び出すのではなく、ファイルを実行して失敗した場合にエラーを処理することをお勧めします。

Note

Julia 1.6 より前は、Windows のファイルシステム ACL を正しく調査しなかったため、任意のファイルに対して true を返していました。Julia 1.6 以降は、ファイルが実行可能としてマークされているかどうかを正しく判断します。

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

source
Base.Sys.isreadableFunction
isreadable(path::String)

与えられた path のアクセス権が現在のユーザーによる読み取りを許可している場合は true を返します。

Note

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

Note

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

Julia 1.11

この関数は少なくともJulia 1.11を必要とします。

関連項目として ispath, isexecutable, iswritable を参照してください。

source
isreadable(io) -> Bool

指定されたIOオブジェクトが読み取り可能でない場合はfalseを返します。

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           isreadable(io)
       end
false

julia> open("myfile.txt", "r") do io
           isreadable(io)
       end
true

julia> rm("myfile.txt")
source
Base.Sys.iswritableFunction
iswritable(path::String)

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

Note

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

Note

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

Julia 1.11

この関数は少なくともJulia 1.11が必要です。

関連項目として ispathisexecutableisreadable を参照してください。

source
iswritable(io) -> Bool

指定された IO オブジェクトが書き込み可能でない場合は false を返します。

julia> open("myfile.txt", "w") do io
           print(io, "Hello world!");
           iswritable(io)
       end
true

julia> open("myfile.txt", "r") do io
           iswritable(io)
       end
false

julia> rm("myfile.txt")
source
Base.Sys.usernameFunction
Sys.username() -> String

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

環境変数(例:USER)を介して上書き可能なユーザー名を取得するには、次のようにします。

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

この関数は少なくともJulia 1.11が必要です。

関連情報はhomedirを参照してください。

source
Base.@staticMacro
@static

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

例えば、@static Sys.iswindows() ? foo : barSys.iswindows() を評価し、式に foo または bar のいずれかを挿入します。これは、存在しない関数への ccall のように、他のプラットフォームでは無効な構造がある場合に便利です。@static if Sys.isapple() foo end および @static foo <&&,||> bar も有効な構文です。

source

Versioning

Base.VersionNumberType
VersionNumber

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

VersionNumberオブジェクトは、すべての標準比較演算子(==<<=など)で比較でき、その結果はsemverルールに従います。

VersionNumberには以下の公開フィールドがあります:

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

効率的にsemver形式のリテラル文字列からVersionNumberオブジェクトを構築するための@v_str、Julia自体のVersionNumberについてはVERSION、マニュアルのVersion Number Literalsも参照してください。

julia> a = VersionNumber(1, 2, 3)
v"1.2.3"

julia> a >= v"1.2"
true

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

julia> b >= v"2.0.1"
false
source
Base.@v_strMacro
@v_str

文字列をVersionNumberに解析するために使用される文字列マクロです。

julia> v"1.2.3"
v"1.2.3"

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

Errors

Base.errorFunction
error(message::AbstractString)

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

source
error(msg...)

string(msg...)で構築されたメッセージを持つErrorExceptionを発生させます。

source
Base.rethrowFunction
rethrow()

catch ブロック内から現在の例外を再スローします。再スローされた例外は、捕捉されなかったかのように伝播を続けます。

Note

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

source
Base.backtraceFunction
backtrace()

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

source
Base.catch_backtraceFunction
catch_backtrace()

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

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

現在処理中の例外のスタックを取得します。ネストされたキャッチブロックがある場合、現在の例外が複数存在する可能性があり、その場合、最も最近スローされた例外がスタックの最後にあります。スタックは ExceptionStack として返され、これは名前付きタプル (exception,backtrace) の AbstractVector です。backtrace が false の場合、各ペアのバックトレースは nothing に設定されます。

task を明示的に渡すことで、任意のタスクの現在の例外スタックを返します。これは、未処理の例外によって失敗したタスクを検査するのに便利です。

Julia 1.7

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

source
Base.@assertMacro
@assert cond [text]

condfalseの場合、AssertionErrorをスローします。これは、真であると仮定される条件であるアサーションを書くための推奨構文ですが、ユーザーが失敗した場合のデバッグの助けとして、チェックすることを決定するかもしれません。オプションのメッセージtextは、アサーションが失敗した際に表示されます。

Warning

アサートは、いくつかの最適化レベルで無効にされる可能性があります。したがって、アサートはデバッグツールとしてのみ使用され、認証検証(例:パスワードの検証や配列の境界チェック)には使用されるべきではありません。コードは、関数の正しい動作のためにcondを実行する副作用に依存してはなりません。

julia> @assert iseven(3) "3は奇数です!"
ERROR: AssertionError: 3は奇数です!

julia> @assert isodd(3) "偶数とは何ですか?"
source
Base.Experimental.register_error_hintFunction
Experimental.register_error_hint(handler, exceptiontype)

"ヒント" 関数 handler(io, exception) を登録し、ユーザーがエラーを回避するための潜在的な方法を提案できるようにします。 handlerexception を調べて、ヒントに適した条件が満たされているかどうかを確認し、そうであれば io に出力を生成します。パッケージは __init__ 関数内から register_error_hint を呼び出すべきです。

特定の例外タイプに対して、handler は追加の引数を受け取る必要があります:

  • MethodError: handler(io, exc::MethodError, argtypes, kwargs) を提供し、結合された引数を位置引数とキーワード引数に分割します。

ヒントを発行する際、出力は通常 \n で始まるべきです。

カスタム例外タイプを定義する場合、showerror メソッドは Experimental.show_error_hints を呼び出すことでヒントをサポートできます。

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, "\n呼び出そうとしましたか ")
                    printstyled(io, "`any_number`?", color=:cyan)
               end
           end
       end

       end

その後、Hinter.only_intInt でないものに呼び出すと(これにより MethodError が発生し)、ヒントが発行されます:

julia> Hinter.only_int(1.0)
ERROR: MethodError: no method matching only_int(::Float64)
関数 `only_int` は存在しますが、この引数タイプの組み合わせに対して定義されたメソッドはありません。
`any_number` を呼び出そうとしましたか?
最も近い候補は:
    ...
Julia 1.5

カスタムエラーヒントは Julia 1.5 から利用可能です。

Warning

このインターフェースは実験的であり、通知なしに変更または削除される可能性があります。変更に対して自分自身を保護するために、すべての登録を if isdefined(Base.Experimental, :register_error_hint) ... end ブロック内に置くことを検討してください。

source
Base.Experimental.show_error_hintsFunction
Experimental.show_error_hints(io, ex, args...)

特定の例外タイプ typeof(ex) に対して Experimental.register_error_hint からすべてのハンドラーを呼び出します。 args には、そのタイプのハンドラーが期待する他の引数が含まれている必要があります。

Julia 1.5

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

Warning

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

source
Core.ArgumentErrorType
ArgumentError(msg)

関数に渡された引数が無効です。msgは説明的なエラーメッセージです。

source
Core.AssertionErrorType
AssertionError([msg])

主張された条件が true に評価されませんでした。オプションの引数 msg は、説明的なエラーストリングです。

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

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

source
Core.BoundsErrorType
BoundsError([a],[i])

配列 a へのインデックス操作が、インデックス i で範囲外の要素にアクセスしようとしました。

julia> A = fill(1.0, 7);

julia> A[8]
ERROR: BoundsError: attempt to access 7-element Vector{Float64} at index [8]


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

julia> B[2, 4]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [2, 4]


julia> B[9]
ERROR: BoundsError: attempt to access 2×3 Matrix{Float64} at index [9]
source
Base.CompositeExceptionType
CompositeException

Taskによってスローされた例外のVectorをラップし(例えば、チャネルを介してリモートワーカーから生成されたものや、非同期に実行されるローカルI/O書き込み、またはpmapの下でのリモートワーカーからのもの)、例外の系列に関する情報を提供します。例えば、複数のワーカーがいくつかのタスクを実行していて、複数のワーカーが失敗した場合、結果として得られるCompositeExceptionは、各ワーカーからの情報の「バンドル」を含み、例外が発生した場所と理由を示します。

source
Base.DimensionMismatchType
DimensionMismatch([msg])

呼び出されたオブジェクトの次元が一致していません。オプションの引数 msg は、説明的なエラーストリングです。

source
Core.DivideErrorType
DivideError()

整数除算が分母の値が 0 の場合に試みられました。

julia> 2/0
Inf

julia> div(2, 0)
ERROR: DivideError: 整数除算エラー
Stacktrace:
[...]
source
Core.DomainErrorType
DomainError(val)
DomainError(val, msg)

関数またはコンストラクタへの引数 val が有効なドメインの外にあります。

julia> sqrt(-1)
ERROR: DomainError with -1.0:
sqrtは負の実引数で呼び出されましたが、複素引数で呼び出された場合にのみ複素結果を返します。sqrt(Complex(x))を試してください。
Stacktrace:
[...]
source
Base.EOFErrorType
EOFError()

ファイルまたはストリームから読み取るためのデータがもうありませんでした。

source
Core.ErrorExceptionType
ErrorException(msg)

一般的なエラータイプです。エラーメッセージは、.msg フィールドにあり、より具体的な詳細を提供する場合があります。

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

julia> ex.msg
"I've done a bad thing"
source
Core.InexactErrorType
InexactError(name::Symbol, T, val)

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

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

プロセスはターミナルの中断(CTRL+C)によって停止されました。

-i(インタラクティブ)オプションなしで開始されたJuliaスクリプトでは、InterruptExceptionはデフォルトではスローされないことに注意してください。スクリプト内でBase.exit_on_sigint(false)を呼び出すことで、REPLの動作を回復できます。あるいは、次のようにJuliaスクリプトを開始することもできます。

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

これにより、実行中にCTRL+CによってInterruptExceptionがスローされるようになります。

source
Base.KeyErrorType
KeyError(key)

AbstractDictDict)またはSetのようなオブジェクトへのインデックス操作が、存在しない要素にアクセスまたは削除しようとしました。

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

ファイルを include したり、require したり、using したりする際にエラーが発生しました。エラーの詳細は .error フィールドで確認できます。

Julia 1.7

Julia 1.7 以降、@macroexpand@macroexpand1、および macroexpand によって LoadErrors は発生しなくなりました。

source
Core.MethodErrorType
MethodError(f, args)

要求される型シグネチャを持つメソッドが、指定された汎用関数には存在しません。あるいは、ユニークな最も特定的なメソッドが存在しません。

source
Base.MissingExceptionType
MissingException(msg)

missing 値がサポートされていない状況で遭遇したときにスローされる例外。エラーメッセージは、msg フィールドにより、より具体的な詳細を提供する場合があります。

source
Core.OutOfMemoryErrorType
OutOfMemoryError()

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

source
Core.OverflowErrorType
OverflowError(msg)

式の結果が指定された型に対して大きすぎて、ラップアラウンドを引き起こします。

source
Base.ProcessFailedExceptionType
ProcessFailedException

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

source
Base.TaskFailedExceptionType
TaskFailedException

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

source
Core.StackOverflowErrorType
StackOverflowError()

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

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

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

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

型アサーションの失敗、または不正な引数型で内蔵関数を呼び出した場合。

source
Core.UndefKeywordErrorType
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
source
Core.UndefRefErrorType
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:
[...]
source
Core.UndefVarErrorType
UndefVarError(var::Symbol, [scope])

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

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

julia> a = 1;

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

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

source
Core.InitErrorType
InitError(mod::Symbol, error)

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

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

関数 f を呼び出す無名関数を返します。例外が発生した場合、checktrue を返すたびに、delays で指定された秒数待った後に f が再度呼び出されます。checkdelays の現在の状態と Exception を入力する必要があります。

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)
source
Base.ExponentialBackOffType
ExponentialBackOff(; n=1, first_delay=0.05, max_delay=10.0, factor=5.0, jitter=0.1)

長さ nFloat64 イテレータで、その要素は factor * (1 ± jitter) の範囲で指数的に増加します。最初の要素は first_delay で、すべての要素は max_delay に制限されます。

source

Events

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

関数 callback を各タイマーの期限切れ時に実行するタイマーを作成します。

待機中のタスクは起こされ、関数 callback は最初の遅延 delay 秒後に呼び出され、その後は指定された interval 秒ごとに繰り返し呼び出されます。interval0 の場合、コールバックは一度だけ実行されます。関数 callback は、タイマー自体を引数として一つ受け取って呼び出されます。タイマーを停止するには close を呼び出します。タイマーがすでに期限切れの場合、コールバックは最後に一度実行されることがあります。

ここでは、最初の数字が2秒の遅延の後に印刷され、その後の数字はすぐに印刷されます。

julia> begin
           i = 0
           cb(timer) = (global i += 1; println(i))
           t = Timer(cb, 2, interval=0.2)
           wait(t)
           sleep(0.5)
           close(t)
       end
1
2
3
source
Base.TimerType
Timer(delay; interval = 0)

タスクがそれを待機しているときに起こすタイマーを作成します(タイマーオブジェクトでwaitを呼び出すことによって)。

待機しているタスクは、最初の遅延が少なくともdelay秒経過した後に起こされ、その後は少なくともinterval秒が経過した後に繰り返し起こされます。interval0に等しい場合、タイマーは一度だけトリガーされます。タイマーが閉じられると(closeによって)、待機しているタスクはエラーで起こされます。タイマーがまだアクティブかどうかを確認するにはisopenを使用してください。

Note

intervalは時間のずれが蓄積される影響を受けます。特定の絶対時間で正確なイベントが必要な場合は、次の時間までの差を計算して、各満了時に新しいタイマーを作成してください。

Note

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

source
Base.AsyncConditionType
AsyncCondition()

非同期条件を作成し、Cからのuv_async_sendの呼び出しによって通知されたときに、それを待機しているタスクを起こします(オブジェクトでwaitを呼び出すことによって)。オブジェクトが閉じられたとき(closeによって)、待機しているタスクはエラーで起こされます。まだアクティブかどうかを確認するには、isopenを使用します。

これにより、送信スレッドと待機スレッドの間で暗黙の取得と解放のメモリ順序が提供されます。

source
Base.AsyncConditionMethod
AsyncCondition(callback::Function)

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

source

Reflection

Base.nameofMethod
nameof(m::Module) -> Symbol

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

julia> nameof(Base.Broadcast)
:Broadcast
source
Base.parentmoduleFunction
parentmodule(m::Module) -> Module

モジュールの囲む Module を取得します。Main は自分自身の親です。

関連情報: names, nameof, fullname, @__MODULE__.

julia> parentmodule(Main)
Main

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

定義されているモジュールを特定します(潜在的に UnionAll でラップされた) DataType の。

julia> module Foo
           struct Int end
       end
Foo

julia> parentmodule(Int)
Core

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

汎用関数の(最初の)定義を含むモジュールを特定します。

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

指定された types に一致する汎用関数 f の最初のメソッドを含むモジュールを決定します。

source
parentmodule(m::Method) -> Module

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

Julia 1.9

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

source
Base.pathofMethod
pathof(m::Module)

モジュール mimport するために使用された m.jl ファイルのパスを返します。モジュール m がパッケージからインポートされていない場合は nothing を返します。

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

さらに pkgdir も参照してください。

source
Base.pkgdirMethod
pkgdir(m::Module[, paths::String...])

モジュール m を宣言したパッケージのルートディレクトリを返します。m がパッケージ内で宣言されていない場合は nothing を返します。オプションで、パッケージのルート内のパスを構成するために、さらにパスコンポーネントの文字列を提供できます。

現在のモジュールを実装しているパッケージのルートディレクトリを取得するには、pkgdir(@__MODULE__) の形式を使用できます。

拡張モジュールが指定された場合は、親パッケージのルートが返されます。

julia> pkgdir(Foo)
"/path/to/Foo.jl"

julia> pkgdir(Foo, "src", "file.jl")
"/path/to/Foo.jl/src/file.jl"

他にも pathof を参照してください。

Julia 1.7

オプション引数 paths は少なくとも Julia 1.7 が必要です。

source
Base.pkgversionMethod
pkgversion(m::Module)

モジュール m をインポートしたパッケージのバージョンを返します。m がパッケージからインポートされていない場合、またはバージョンフィールドが設定されていないパッケージからインポートされた場合は nothing を返します。

バージョンはパッケージの Project.toml からパッケージのロード時に読み取られます。

現在のモジュールをインポートしたパッケージのバージョンを取得するには、pkgversion(@__MODULE__) の形式を使用できます。

Julia 1.9

この関数は Julia 1.9 で導入されました。

source
Base.modulerootFunction
moduleroot(m::Module) -> Module

与えられたモジュールのルートモジュールを見つけます。これは、m の親モジュールのチェーンの中で、登録されたルートモジュールであるか、自身が親モジュールである最初のモジュールです。

source
__module__Keyword
__module__

引数 __module__ はマクロ内でのみ可視であり、マクロ呼び出しの展開コンテキストに関する情報(Module オブジェクトの形式で)を提供します。詳細については、マクロ呼び出し に関するマニュアルのセクションを参照してください。

source
__source__Keyword
__source__

引数 __source__ はマクロ内でのみ可視であり、マクロ呼び出しからの @ 記号のパーサー位置に関する情報(LineNumberNode オブジェクトの形式で)を提供します。詳細については、マクロ呼び出し に関するマニュアルのセクションを参照してください。

source
Base.@__MODULE__Macro
@__MODULE__ -> モジュール

現在読み込まれているコードのモジュールであるトップレベル評価のモジュールを取得します。

source
Base.@__FILE__Macro
@__FILE__ -> String

マクロ呼び出しを含むファイルへのパスを持つ文字列に展開します。julia -e <expr> で評価された場合は空の文字列を返します。マクロがパーサーソース情報を欠いている場合は nothing を返します。代わりに PROGRAM_FILE を参照してください。

source
Base.@__DIR__Macro
@__DIR__ -> String

現在のディレクトリの絶対パスを文字列として取得するためのマクロです。

スクリプト内で使用される場合、@__DIR__マクロ呼び出しを含むスクリプトのディレクトリを返します。REPLから実行するか、julia -e <expr>で評価される場合は、現在の作業ディレクトリを返します。

この例は、現在の作業ディレクトリとは異なるディレクトリに簡単なスクリプトを作成し、@__DIR__pwd()の動作の違いを示しています:

julia> cd("/home/JuliaUser") # 作業ディレクトリ

julia> # /home/JuliaUser/Projectsにスクリプトを作成
       open("/home/JuliaUser/Projects/test.jl","w") do io
           print(io, """
               println("@__DIR__ = ", @__DIR__)
               println("pwd() = ", pwd())
           """)
       end

julia> # スクリプトのディレクトリと現在の作業ディレクトリを出力
       include("/home/JuliaUser/Projects/test.jl")
@__DIR__ = /home/JuliaUser/Projects
pwd() = /home/JuliaUser
source
Base.@__LINE__Macro
@__LINE__ -> Int

マクロ呼び出しの位置の行番号に展開されます。行番号が特定できない場合は 0 を返します。

source
Base.fullnameFunction
fullname(m::Module)

モジュールの完全修飾名をシンボルのタプルとして取得します。例えば、

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

julia> fullname(Main)
(:Main,)
source
Base.namesFunction
names(x::Module; all::Bool = false, imported::Bool = false)

Moduleの公開名のベクターを取得します。非推奨の名前は除外されます。allがtrueの場合、リストにはモジュール内で定義された非公開名、非推奨の名前、およびコンパイラ生成の名前も含まれます。importedがtrueの場合、他のモジュールから明示的にインポートされた名前も含まれます。名前はソートされた順序で返されます。

特別なケースとして、Mainで定義されたすべての名前は「公開」と見なされます。なぜなら、Mainからの名前を明示的に公開としてマークすることは慣習的ではないからです。

Note

sym ∈ names(SomeModule)isdefined(SomeModule, sym)を意味しません。namesは、モジュール内で定義されていなくても、publicまたはexportとしてマークされたシンボルを返します。

参照: Base.isexported, Base.ispublic, Base.@locals, @__MODULE__.

source
Base.isexportedFunction
isexported(m::Module, s::Symbol) -> Bool

モジュールからシンボルがエクスポートされているかどうかを返します。

関連情報: ispublic, names

julia> module Mod
           export foo
           public bar
       end
Mod

julia> Base.isexported(Mod, :foo)
true

julia> Base.isexported(Mod, :bar)
false

julia> Base.isexported(Mod, :baz)
false
source
Base.ispublicFunction
ispublic(m::Module, s::Symbol) -> Bool

モジュール内でシンボルが公開されているかどうかを返します。

エクスポートされたシンボルは公開と見なされます。

Julia 1.11

この関数と公開性の概念はJulia 1.11で追加されました。

関連情報: isexported, names

julia> module Mod
           export foo
           public bar
       end
Mod

julia> Base.ispublic(Mod, :foo)
true

julia> Base.ispublic(Mod, :bar)
true

julia> Base.ispublic(Mod, :baz)
false
source
Base.nameofMethod
nameof(f::Function) -> Symbol

汎用 Function の名前をシンボルとして取得します。匿名関数の場合、これはコンパイラ生成の名前です。明示的に宣言された Function のサブタイプの場合、それは関数の型の名前です。

source
Base.functionlocMethod
functionloc(f::Function, types)

汎用 Function 定義の位置を示すタプル (filename,line) を返します。

source
Base.functionlocMethod
functionloc(m::Method)

Method 定義の位置を示すタプル (filename,line) を返します。

source
Base.@localsMacro
@locals()

呼び出し元の時点で定義されているすべてのローカル変数の名前(シンボルとして)と値の辞書を構築します。

Julia 1.1

このマクロは少なくともJulia 1.1が必要です。

julia> let x = 1, y = 2
           Base.@locals
       end
Dict{Symbol, Any} with 2 entries:
  :y => 2
  :x => 1

julia> function f(x)
           local y
           show(Base.@locals); println()
           for i = 1:1
               show(Base.@locals); println()
           end
           y = 2
           show(Base.@locals); println()
           nothing
       end;

julia> f(42)
Dict{Symbol, Any}(:x => 42)
Dict{Symbol, Any}(:i => 1, :x => 42)
Dict{Symbol, Any}(:y => 2, :x => 42)
source
Core.getglobalFunction
getglobal(module::Module, name::Symbol, [order::Symbol=:monotonic])

モジュール module からバインディング name の値を取得します。オプションで、操作のための原子的な順序を定義できます。指定しない場合は、デフォルトで単調になります。

getfield を使用してモジュールのバインディングにアクセスすることは互換性を維持するためにまだサポートされていますが、getglobal を使用することが常に推奨されます。なぜなら、getglobal は原子的な順序を制御できるため(getfield は常に単調です)、ユーザーやコンパイラに対してコードの意図をより明確に示すことができるからです。

ほとんどのユーザーはこの関数を直接呼び出す必要はありません – getproperty 関数または対応する構文(すなわち module.name)が、非常に特定の使用ケースを除いて常に推奨されます。

Julia 1.9

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

他にも getpropertysetglobal! を参照してください。

julia> a = 1
1

julia> module M
       a = 2
       end;

julia> getglobal(@__MODULE__, :a)
1

julia> getglobal(M, :a)
2
source
Core.setglobal!Function
setglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])

モジュール module 内のバインディング name の値を x に設定または変更します。型変換は行われないため、バインディングに対してすでに型が宣言されている場合、x は適切な型でなければならず、そうでない場合はエラーが発生します。

さらに、この操作に対して原子的な順序を指定することができ、指定しない場合はデフォルトで単調になります。

ユーザーは通常、この機能に setproperty! 関数または対応する構文(すなわち module.name = x)を通じてアクセスするため、これは非常に特定の使用ケースのために意図されています。

Julia 1.9

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

他に setproperty!getglobal も参照してください。

julia> module M; global a; end;

julia> M.a  # `getglobal(M, :a)` と同じ
ERROR: UndefVarError: `a` not defined in `M`
Suggestion: add an appropriate import or assignment. This global was declared but not assigned.
Stacktrace:
 [1] getproperty(x::Module, f::Symbol)
   @ Base ./Base.jl:42
 [2] top-level scope
   @ none:1

julia> setglobal!(M, :a, 1)
1

julia> M.a
1
source
Core.modifyglobal!Function
modifyglobal!(module::Module, name::Symbol, op, x, [order::Symbol=:monotonic]) -> Pair

関数 op を適用した後にグローバルを取得して設定する操作を原子的に実行します。

Julia 1.11

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

他に modifyproperty!setglobal! を参照してください。

source
Core.swapglobal!Function
swapglobal!(module::Module, name::Symbol, x, [order::Symbol=:monotonic])

原子的に操作を実行して、グローバルを同時に取得して設定します。

Julia 1.11

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

他にswapproperty!setglobal!も参照してください。

source
Core.setglobalonce!Function
setglobalonce!(module::Module, name::Symbol, value,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> success::Bool

与えられた値にグローバルを設定する操作を原子的に実行します。以前に設定されていない場合のみ実行されます。

Julia 1.11

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

setpropertyonce! および setglobal! も参照してください。

source
Core.replaceglobal!Function
replaceglobal!(module::Module, name::Symbol, expected, desired,
              [success_order::Symbol, [fail_order::Symbol=success_order]) -> (; old, success::Bool)

原子操作を実行して、グローバルを指定された値に条件付きで設定します。

Julia 1.11

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

他にreplaceproperty!setglobal!も参照してください。

source

Documentation

documentation章も参照してください。)

Core.@docMacro

ドキュメンテーション

関数、メソッド、型は、定義の前に文字列を置くことでドキュメント化できます:

"""
# Foo関数
`foo(x)`: `x`を徹底的にFooします。
"""
foo(x) = ...

@docマクロは、ドキュメント/メタデータを設定および取得するために直接使用できます。このマクロには特別なパースがあり、ドキュメント化されたオブジェクトは次の行に現れることができます:

@doc "blah"
function foo() ...

デフォルトでは、ドキュメントはMarkdownとして書かれますが、任意のオブジェクトを最初の引数として使用できます。

定義から独立してオブジェクトをドキュメント化する

オブジェクトをその定義の前または後にドキュメント化することができます:

@doc "foo" function_to_doc
@doc "bar" TypeToDoc

マクロの場合、構文は @doc "macro doc" :(Module.@macro) または文字列マクロの場合は @doc "macro doc" :(string_macro"") です。引用符 :() がない場合、マクロの展開がドキュメント化されます。

ドキュメントの取得

関数、マクロ、その他のオブジェクトのドキュメントを次のように取得できます:

@doc foo
@doc @time
@doc md""

関数とメソッド

メソッド定義の前にドキュメントを置く(例:function foo() ... または foo() = ...)と、その特定のメソッドがドキュメント化され、関数全体ではなくなります。メソッドのドキュメントは、定義された順序で連結されて、関数のドキュメントを提供します。

source
Base.Docs.HTMLType

HTML(s): sをhtmlとしてレンダリングするオブジェクトを作成します。

HTML("<div>foo</div>")

大量のデータにはストリームを使用することもできます:

HTML() do io
  println(io, "<div>foo</div>")
end
Warning

HTMLは現在、後方互換性を維持するためにエクスポートされていますが、このエクスポートは非推奨です。この型はDocs.HTMLとして使用するか、Docsから明示的にインポートすることをお勧めします。

source
Base.Docs.TextType

Text(s): sをプレーンテキストとしてレンダリングするオブジェクトを作成します。

Text("foo")

大量のデータにはストリームを使用することもできます:

Text() do io
  println(io, "foo")
end
Warning

Textは現在、後方互換性を維持するためにエクスポートされていますが、このエクスポートは非推奨です。この型はDocs.Textとして使用するか、Docsから明示的にインポートすることをお勧めします。

source
Base.Docs.hasdocFunction
Docs.hasdoc(mod::Module, sym::Symbol)::Bool

symmod に存在し、ドキュメント文字列がある場合は true を返し、そうでない場合は false を返します。

source
Base.Docs.undocumented_namesFunction
undocumented_names(mod::Module; private=false)

ドキュメントがないシンボルのソートされたベクターを module から返します(つまり、ドキュメント文字列が欠けているもの)。private=false(デフォルト)では、public および/または export で宣言された識別子のみを返しますが、private=true ではモジュール内のすべてのシンボルを返します(コンパイラ生成の隠しシンボルである # で始まるものは除く)。

関連情報: names, Docs.hasdoc, Base.ispublic.

source

Code loading

Base.identify_packageFunction
Base.identify_package(name::String)::Union{PkgId, Nothing}
Base.identify_package(where::Union{Module,PkgId}, name::String)::Union{PkgId, Nothing}

現在の環境スタックから名前でパッケージを特定し、そのPkgIdを返します。見つからない場合はnothingを返します。

name引数のみが提供された場合、スタック内の各環境とその名前付き直接依存関係を検索します。

where引数は、パッケージを検索するコンテキストを提供します。この場合、まず名前がコンテキスト自体と一致するかを確認し、一致しない場合は、コンテキストwhereを特定するまで、各環境の解決されたマニフェストからすべての再帰的依存関係を検索し、そこから対応する名前の依存関係を特定します。

julia> Base.identify_package("Pkg") # Pkgはデフォルト環境の依存関係です
Pkg [44cfe95a-1eb2-52ea-b672-e2afdf69b78f]

julia> using LinearAlgebra

julia> Base.identify_package(LinearAlgebra, "Pkg") # PkgはLinearAlgebraの依存関係ではありません
source
Base.locate_packageFunction
Base.locate_package(pkg::PkgId)::Union{String, Nothing}

識別子 pkg に対応するパッケージのエントリポイントファイルへのパス、または見つからない場合は nothing。詳細は identify_package を参照。

julia> pkg = Base.identify_package("Pkg")
Pkg [44cfe95a-1eb2-52ea-b672-e2afdf69b78f]

julia> Base.locate_package(pkg)
"/path/to/julia/stdlib/v1.11/Pkg/src/Pkg.jl"
source
Base.requireFunction
require(into::Module, module::Symbol)

この関数は、モジュールが Main にまだ定義されていない場合に、using / import の実装の一部です。また、モジュールが以前にロードされていたかどうかに関係なく、モジュールの再ロードを強制するために直接呼び出すこともできます(たとえば、ライブラリをインタラクティブに開発しているとき)。

アクティブなすべてのノードで、Main モジュールのコンテキスト内でソースファイルをロードし、標準の場所でファイルを検索します。require はトップレベルの操作と見なされるため、現在の include パスを設定しますが、ファイルを検索するためには使用しません(include のヘルプを参照)。この関数は通常、ライブラリコードをロードするために使用され、パッケージをロードするために using によって暗黙的に呼び出されます。

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

コードのロードに関する詳細については、モジュール および 並列計算 に関するマニュアルのセクションを参照してください。

source
Base.compilecacheFunction
Base.compilecache(module::PkgId)

モジュールとそのすべての依存関係のためのプリコンパイルキャッシュファイルを作成します。これはパッケージのロード時間を短縮するために使用できます。キャッシュファイルは DEPOT_PATH[1]/compiled に保存されます。重要な注意事項については Module initialization and precompilation を参照してください。

source
Base.isprecompiledFunction
Base.isprecompiled(pkg::PkgId; ignore_loaded::Bool=false)

指定されたプロジェクト内の PkgId がプリコンパイルされているかどうかを返します。

デフォルトでは、このチェックは、異なるバージョンの依存関係が現在読み込まれている場合に、コードの読み込みが期待されるものと同じアプローチを観察します。読み込まれたモジュールを無視し、新しい Julia セッションのように答えるには、ignore_loaded=true を指定します。

Julia 1.10

この関数は少なくとも Julia 1.10 が必要です。

source
Base.get_extensionFunction
get_extension(parent::Module, extension::Symbol)

parentextensionのモジュールを返すか、拡張がロードされていない場合はnothingを返します。

source

Internals

Base.GC.gcFunction
GC.gc([full=true])

ガーベジコレクションを実行します。引数 full はコレクションの種類を決定します:フルコレクション(デフォルト)はすべての生存オブジェクト(すなわちフルマーク)を走査し、到達不可能なオブジェクトからメモリを回収する必要があります。インクリメンタルコレクションは、到達不可能ではない若いオブジェクトからのみメモリを回収します。

GCは、インクリメンタルコレクションが要求された場合でも、フルコレクションを実行することを決定する場合があります。

Warning

過度の使用はパフォーマンスの低下を引き起こす可能性があります。

source
Base.GC.enableFunction
GC.enable(on::Bool)

ガーベジコレクションが有効かどうかをブール引数(true は有効、false は無効)を使って制御します。前のGC状態を返します。

Warning

ガーベジコレクションを無効にすることは慎重に行うべきであり、メモリ使用量が無限に増加する可能性があります。

source
Base.GC.@preserveMacro
GC.@preserve x1 x2 ... xn expr

オブジェクト x1, x2, ... を式 expr の評価中に 使用中 としてマークします。これは、exprx のいずれかが所有するメモリやその他のリソースを 暗黙的に使用する 場合にのみ、unsafe コードで必要です。

x暗黙的な使用 には、コンパイラが見ることができない x に論理的に所有されるリソースの間接的な使用が含まれます。いくつかの例:

  • Ptr を介してオブジェクトのメモリに直接アクセスする
  • ccallx へのポインタを渡す
  • 最終化子でクリーンアップされる x のリソースを使用する

@preserve は、オブジェクトのライフタイムを一時的に延長する典型的な使用ケースでは、一般的にパフォーマンスに影響を与えないはずです。実装において、@preserve は動的に割り当てられたオブジェクトをガーベジコレクションから保護するなどの効果があります。

unsafe_load でポインタから読み込むとき、基になるオブジェクトは暗黙的に使用されます。たとえば、次のように unsafe_load(p) によって x が暗黙的に使用されます。

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

ポインタを ccall に渡すとき、指し示すオブジェクトは暗黙的に使用され、保持されるべきです。(ただし、通常は x を直接 ccall に渡すべきであり、これは明示的な使用としてカウントされます。)

julia> let
           x = "Hello"
           p = pointer(x)
           Int(GC.@preserve x @ccall strlen(p::Cstring)::Csize_t)
           # 推奨される代替
           Int(@ccall strlen(x::Cstring)::Csize_t)
       end
5
source
Base.GC.safepointFunction
GC.safepoint()

プログラム内でガーベジコレクションが実行される可能性のあるポイントを挿入します。これは、いくつかのスレッドがメモリを割り当てている(したがってGCを実行する必要があるかもしれない)一方で、他のスレッドが単純な操作(割り当て、タスクスイッチ、またはI/Oなし)だけを行っているマルチスレッドプログラムの稀なケースで役立ちます。割り当てを行わないスレッドでこの関数を定期的に呼び出すことで、ガーベジコレクションが実行されることを可能にします。

Julia 1.4

この関数はJulia 1.4以降で利用可能です。

source
Base.GC.enable_loggingFunction
GC.enable_logging(on::Bool)

オンにすると、各GCに関する統計をstderrに出力します。

source
Base.Meta.lowerFunction
lower(m, x)

x を受け取り、モジュール m で実行するための同等の式を低下形式で返します。詳細は code_lowered を参照してください。

source
Base.Meta.@lowerMacro
@m下げ [m] x

モジュール m における式 x の下げられた形式を返します。デフォルトでは、m はマクロが呼び出されたモジュールです。詳細は lower を参照してください。

source
Base.Meta.parseMethod
parse(str, start; greedy=true, raise=true, depwarn=true, filename="none")

式の文字列を解析し、式を返します(これは後でevalに渡して実行することができます)。startは、解析を開始する最初の文字のstr内のコードユニットインデックスです(すべての文字列インデックスと同様に、これは文字インデックスではありません)。greedytrue(デフォルト)の場合、parseはできるだけ多くの入力を消費しようとします。そうでない場合、有効な式を解析した時点で停止します。未完成だがそれ以外は構文的に有効な式はExpr(:incomplete, "(エラーメッセージ)")を返します。raisetrue(デフォルト)の場合、未完成の式以外の構文エラーはエラーを発生させます。raisefalseの場合、parseは評価時にエラーを発生させる式を返します。depwarnfalseの場合、非推奨警告は抑制されます。filename引数は、エラーが発生したときに診断情報を表示するために使用されます。

julia> Meta.parse("(α, β) = 3, 5", 1) # 文字列の開始
(:((α, β) = (3, 5)), 16)

julia> Meta.parse("(α, β) = 3, 5", 1, greedy=false)
(:((α, β)), 9)

julia> Meta.parse("(α, β) = 3, 5", 16) # 文字列の終わり
(nothing, 16)

julia> Meta.parse("(α, β) = 3, 5", 11) # 3のインデックス
(:((3, 5)), 16)

julia> Meta.parse("(α, β) = 3, 5", 11, greedy=false)
(3, 13)
source
Base.Meta.parseMethod
parse(str; raise=true, depwarn=true, filename="none")

式の文字列を貪欲に解析し、単一の式を返します。最初の式の後に追加の文字がある場合はエラーがスローされます。raisetrue(デフォルト)である場合、構文エラーはエラーをスローします。そうでない場合、parseは評価時にエラーをスローする式を返します。depwarnfalseの場合、非推奨警告は抑制されます。filename引数は、エラーが発生したときに診断を表示するために使用されます。

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

julia> Meta.parse("1.0.2")
ERROR: ParseError:
# Error @ none:1:1
1.0.2
└──┘ ── 無効な数値定数
[...]

julia> Meta.parse("1.0.2"; raise = false)
:($(Expr(:error, "無効な数値定数 "1.0."")))

julia> Meta.parse("x = ")
:($(Expr(:incomplete, "不完全: 入力の早期終了")))
source
Base.macroexpandFunction
macroexpand(m::Module, x; recursive=true)

x を取り、モジュール m で実行するためにすべてのマクロが削除された(展開された)同等の式を返します。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)
source
Base.@macroexpandMacro
@macroexpand [mod,] ex

すべてのマクロが削除された(展開された)同等の式を返します。2つの引数が提供される場合、最初の引数は評価するモジュールです。

@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 (methodを1つ持つマクロ)

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

@macroexpandを使用すると、式はコード内で@macroexpandが出現する場所(例ではモジュールM)で展開されます。macroexpandを使用すると、式は最初の引数として与えられたモジュールで展開されます。

Julia 1.11

2引数形式は少なくともJulia 1.11が必要です。

source
Base.code_loweredFunction
code_lowered(f, types; generated=true, debuginfo=:default)

与えられたジェネリック関数と型シグネチャに一致するメソッドの低下した形式(IR)の配列を返します。

generatedfalse の場合、返される CodeInfo インスタンスはフォールバック実装に対応します。フォールバック実装が存在しない場合はエラーがスローされます。generatedtrue の場合、これらの CodeInfo インスタンスはジェネレーターを展開することによって得られるメソッド本体に対応します。

キーワード debuginfo は、出力に存在するコードメタデータの量を制御します。

generatedtrue の場合、types がリーフ型でないとエラーがスローされ、対応するメソッドのいずれかが @generated メソッドである場合にエラーが発生します。

source
Base.code_typedFunction
code_typed(f, types; kw...)

指定された汎用関数と型シグネチャに一致するメソッドの型推論された低レベル形式(IR)の配列を返します。

キーワード引数

  • optimize::Bool = true: オプションで、インライン化などの追加最適化が適用されるかどうかを制御します。
  • debuginfo::Symbol = :default: オプションで、出力に含まれるコードメタデータの量を制御します。可能なオプションは :source または :none です。

内部キーワード引数

このセクションは内部的なものであり、Juliaコンパイラの内部を理解している人のためのものです。

  • world::UInt = Base.get_world_counter(): オプションで、メソッドを検索する際に使用するワールドエイジを制御します。指定されていない場合は現在のワールドエイジを使用します。
  • interp::Core.Compiler.AbstractInterpreter = Core.Compiler.NativeInterpreter(world): オプションで、使用する抽象インタプリタを制御します。指定されていない場合はネイティブインタプリタを使用します。

引数の型をタプルに入れることで、対応する code_typed を取得できます。

julia> code_typed(+, (Float64, Float64))
1-element Vector{Any}:
 CodeInfo(
1 ─ %1 = Base.add_float(x, y)::Float64
└──      return %1
) => Float64
source
Base.precompileFunction
precompile(f, argtypes::Tuple{Vararg{Any}})

与えられた関数 f を引数タプル(型の) argtypes に対してコンパイルしますが、実行はしません。

source
precompile(f, argtypes::Tuple{Vararg{Any}}, m::Method)

指定された引数の型に対して特定のメソッドをプリコンパイルします。これは、通常ディスパッチによって選択されるメソッドとは異なるメソッドをプリコンパイルするために使用でき、invokeを模倣します。

source
Base.jit_total_bytesFunction
Base.jit_total_bytes()

JITコンパイラによって割り当てられた合計量(バイト単位)を返します。例えば、ネイティブコードやデータなどです。

source

Meta

Base.Meta.quotFunction
Meta.quot(ex)::Expr

ex を引用して、頭が quote の式を生成します。これは例えば、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)
source
Base.isexprFunction
Meta.isexpr(ex, head[, n])::Bool

ex が指定された型 headExpr であり、オプションで引数リストの長さが n である場合に true を返します。headSymbol または Symbol のコレクションである可能性があります。たとえば、マクロに関数呼び出し式が渡されたかどうかを確認するには、isexpr(ex, :call) を使用することができます。

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

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

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

julia> Meta.isexpr(ex, [:block, :call]) # 複数の可能なヘッド
true

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

julia> Meta.isexpr(ex, :call, 2)
true
source
Base.isidentifierFunction
 isidentifier(s) -> Bool

シンボルまたは文字列 s が、Julia コード内で有効な通常の識別子(バイナリ/ユニアリオペレーターではない)として解析される文字を含むかどうかを返します。詳細は Base.isoperator を参照してください。

内部的に、Julia は Symbol 内の任意の文字列のシーケンスを許可します(\0 を除く)。マクロは、周囲のコードとの名前の衝突を避けるために # を含む変数名を自動的に使用します。パーサーが変数を認識するためには、限られた文字のセットを使用します(Unicode によって大幅に拡張されています)。isidentifier() を使用すると、シンボルが有効な文字を含むかどうかをパーサーに直接問い合わせることができます。

julia> Meta.isidentifier(:x), Meta.isidentifier("1x")
(true, false)
source
Base.isoperatorFunction
isoperator(s::Symbol)

シンボルが演算子として使用できる場合は true を返し、それ以外の場合は false を返します。

julia> Meta.isoperator(:+), Meta.isoperator(:f)
(true, false)
source
Base.isunaryoperatorFunction
isunaryoperator(s::Symbol)

記号が単項(接頭辞)演算子として使用できる場合は true を返し、それ以外の場合は false を返します。

julia> Meta.isunaryoperator(:-), Meta.isunaryoperator(:√), Meta.isunaryoperator(:f)
(true, true, false)
source
Base.isbinaryoperatorFunction
isbinaryoperator(s::Symbol)

シンボルが二項(中置)演算子として使用できる場合は true を返し、それ以外の場合は false を返します。

julia> Meta.isbinaryoperator(:-), Meta.isbinaryoperator(:√), Meta.isbinaryoperator(:f)
(true, false, false)
source
Base.Meta.show_sexprFunction
Meta.show_sexpr([io::IO,], ex)

ex をリスプスタイルのS式として表示します。

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