Scope of Variables
変数のスコープとは、その変数を参照できるコードの範囲です。変数のスコープを定めることで、変数名の衝突を避けやすくなります。この考え方は直感的です。たとえば、2つの関数がどちらも引数に x という名前を使っていても、2つの x が同じものを指すとは限りません。同様に、異なるコードブロックが同じ名前を使っていても、同じものを指さない場合はほかにも数多くあります。同じ変数名が同じものを指す場合とそうでない場合を定める規則を、スコープ規則と呼びます。この節では、その詳細を説明します。
言語の一部の構文は、変数のスコープになり得るコード領域であるスコープブロックを導入します。変数のスコープは任意のソースコード行の集合ではなく、必ずこうしたブロックのいずれかに対応します。Juliaのスコープには、主にグローバルスコープとローカルスコープの2種類があります。ローカルスコープは入れ子にできます。またJuliaでは、「ハードスコープ」を導入する構文と、「ソフトスコープ」だけを導入する構文が区別されます。この違いによって、同じ名前のグローバル変数が許されるかどうかが変わります。shadowing
グローバルスコープで定義された変数は、安全性と利便性のバランスを取るため、コードの実行場所によっては内側のローカルスコープから未定義として扱われることがあります。ハードスコープとソフトスコープの規則が、グローバル変数とローカル変数の相互作用を定めます。
一方、ローカルスコープだけで定義された変数は、どのコンテキストでも一貫して動作します。変数がすでに定義されていれば、その変数が再利用されます。定義されていなければ、現在のスコープとその内側のスコープで使えるようになります(外側のスコープでは使えません)。
予期せず変数が未定義になった場合は、
# Print the numbers 1 through 5
i = 0
while i < 5
i += 1 # ERROR: UndefVarError: `i` not defined
println(i)
endコードを let ブロックまたは function で囲み、すべてのグローバル変数の定義をローカル変数の定義に変えると、簡単に解決できることがあります。
# Print the numbers 1 through 5
let i = 0
while i < 5
i += 1 # Now outer `i` is defined in the inner scope of the while loop
println(i)
end
endこれは手続き型スクリプトを書くときによくある混乱の原因ですが、コードを関数内に移すか、REPLで対話的に実行すれば問題になりません。
Scope Constructs
スコープブロックを導入する構文は次のとおりです。
| 構文 | 導入されるスコープの種類 | 構文を含められるスコープの種類 |
|---|---|---|
module, baremodule | グローバル | グローバル |
struct | ローカル(ハード) | グローバル |
macro | ローカル(ハード) | グローバル |
for, while, try | ローカル(ソフト) | グローバル、ローカル |
function, do, let, comprehensions, generators | ローカル(ハード) | グローバル、ローカル |
この表にない begin blocks と if blocks は、新しいスコープを導入しません。スコープには3種類あり、それぞれ規則が少し異なります。以下で説明します。
Juliaは lexical scoping を採用しています。つまり、関数のスコープは呼び出し元のスコープを引き継ぐのではなく、その関数が定義されたスコープを引き継ぎます。たとえば、次のコードでは、foo 内の x は、モジュール Bar のグローバルスコープにある x を指します。
julia> module Bar
x = 1
foo() = x
end;foo が使われるスコープにある x を指すのではありません。
julia> import .Bar
julia> x = -1;
julia> Bar.foo()
1したがって、レキシカルスコープとは、あるコード片にある変数が何を指すかは、そのコード片だけから判断でき、プログラムの実行方法には依存しないということです。あるスコープの内側にあるスコープからは、それを囲むすべての外側のスコープにある変数を参照できます。一方、外側のスコープから内側のスコープにある変数を参照することはできません。
Global Scope
各モジュールは、ほかのすべてのモジュールのグローバルスコープとは別の、新しいグローバルスコープを導入します。すべてを包含するグローバルスコープはありません。モジュールは、using or import 文や、ドット記法による修飾アクセスを通じて、ほかのモジュールの変数を自分のスコープに取り込めます。つまり、各モジュールは、名前と値を対応付ける第一級のデータ構造であると同時に、いわゆる名前空間でもあります。
トップレベルの式にキーワード local を使った変数宣言が含まれている場合、その変数は式の外からは参照できません。式の内側にある変数は、同じ名前のグローバル変数に影響しません。たとえば、トップレベルの begin ブロックまたは if ブロック内で local x を宣言する場合がこれに当たります。
julia> x = 1
begin
local x = 0
@show x
end
@show x;
x = 0
x = 1対話型プロンプト(REPLとも呼ばれます)は、モジュール Main のグローバルスコープにあることに注意してください。
Local Scope
ほとんどのコードブロックは、新しいローカルスコープを導入します(一覧は上記の table を参照)。そのようなブロックが別のローカルスコープの構文上の内側にある場合、ブロックが作るスコープは、そのブロックを囲むすべてのローカルスコープの内側に置かれます。これらのスコープは最終的に、コードが評価されるモジュールのグローバルスコープの内側にあります。外側のスコープにある変数は、それを含むどのスコープからも参照できます。つまり、内側のスコープから読み書きできます。ただし、同じ名前の変数がある場合は、外側の変数が「シャドーイング」されます。外側のローカル変数が内側のブロックより後(テキスト上で下)に宣言されている場合も同様です。あるスコープに変数が「存在する」と言うときは、現在のスコープと、それを囲むすべてのスコープのいずれかに、その名前の変数が存在することを意味します。ローカルスコープで変数の値を使おうとしたとき、その名前の変数がどのスコープにも存在しなければ、その変数はグローバルだと見なされます。
プログラミング言語によっては、新しい変数を使う前に明示的に宣言する必要があります。Juliaでも明示的な宣言が可能です。任意のローカルスコープで local x と書くと、外側のスコープに x という名前の変数がすでにあるかどうかにかかわらず、そのスコープに新しいローカル変数が宣言されます。しかし、新しい変数をすべてこのように宣言するのは冗長で面倒です。そのためJuliaは、多くの言語と同様に、まだ存在しない変数名への代入によって、その変数が暗黙的に宣言されるものとします。現在のスコープがグローバルなら、新しい変数はグローバルになります。ローカルなら、新しい変数は最も内側のローカルスコープに属し、そのスコープ内からは参照できますが、外からは参照できません。既存のローカル変数に代入すると、必ずその変数が更新されます。ローカル変数をシャドーイングできるのは、入れ子になったスコープで local キーワードを使い、新しいローカル変数を明示的に宣言した場合だけです。特に、これは内側の関数で代入される変数にも当てはまります。内側の関数で代入すると、変数を明示的に非ローカルとして宣言しない限り新しいローカル変数が作られるPythonに慣れているユーザーは、意外に思うかもしれません。
大まかには直感的な動作ですが、直感的に見える多くの事柄と同様、細部は一見したほど単純ではありません。
ローカルスコープで x = <value> が現れた場合、Juliaは代入式の位置と、その位置で x がすでに何を指しているかに基づいて、式の意味を次の規則で決定します。
既存のローカル変数:
xがすでにローカル変数なら、既存のローカル変数xに代入します。ハードスコープ:
xがまだローカル変数ではなく、ハードスコープを導入する構文(letブロック、関数、構造体またはマクロの本体、内包表記、ジェネレーター)の内側で代入が行われる場合、代入位置のスコープにxという名前の新しいローカル変数が作られます。ソフトスコープ:
xがまだローカル変数ではなく、代入を囲むスコープ構文がすべてソフトスコープ(ループ、try/catchブロック)の場合、動作はグローバル変数xが定義されているかどうかによって変わります。グローバル変数
xが未定義なら、代入位置のスコープにxという名前の新しいローカル変数が作られます。グローバル変数
xが定義済みなら、代入は曖昧と見なされます。- 非対話型のコンテキスト(ファイル、eval)では、曖昧さに関する警告が表示され、新しいローカル変数が作られます。
- 対話型のコンテキスト(REPL、ノートブック)では、グローバル変数
xに代入します。
非対話型のコンテキストでは、暗黙的にローカルとなる変数(つまり local x で宣言されていない変数)がグローバル変数をシャドーイングすると警告が表示される点を除けば、ハードスコープとソフトスコープの動作は同じです。対話型のコンテキストでは、利便性を考慮して、より複雑なヒューリスティックに従います。詳しくは、後の例で説明します。
規則が分かったところで、いくつか例を見てみましょう。各例は、新しいREPLセッションで評価するものとします。つまり、各コード片で代入される変数だけがグローバル変数として存在します。
まずは、明快なケースから始めましょう。ハードスコープである関数本体内で、同じ名前のローカル変数がまだ存在しない場合の代入です。
julia> function greet()
x = "hello" # new local
println(x)
end
greet (generic function with 1 method)
julia> greet()
hello
julia> x # global
ERROR: UndefVarError: `x` not defined in `Main`greet 関数内の代入 x = "hello" によって、x は関数のスコープに属する新しいローカル変数になります。ここで関係するのは、代入がローカルスコープで行われることと、既存のローカル変数 x がないことの2点です。x はローカル変数なので、同じ名前のグローバル変数 x があるかどうかは関係ありません。たとえば、ここでは x = 123 を定義してから、greet を定義して呼び出します。
julia> x = 123 # global
123
julia> function greet()
x = "hello" # new local
println(x)
end
greet (generic function with 1 method)
julia> greet()
hello
julia> x # global
123greet 内の x はローカル変数なので、greet を呼び出しても、グローバル変数 x の値(または未定義であること)には影響しません。ハードスコープの規則では、x という名前のグローバル変数があるかどうかは関係ありません。ハードスコープ内で x に代入するとローカル変数への代入になります(x が global と宣言されている場合を除きます)。
次に、x という名前のローカル変数がすでにある場合を考えます。この場合、x = <value> は常に既存のローカル変数 x に代入します。代入が同じローカルスコープで行われる場合も、同じ関数本体内の内側のローカルスコープで行われる場合も、別の関数の内側に定義された関数(closure とも呼ばれます)の本体で行われる場合も同様です。
例として、1から n までの整数の合計を計算する sum_to 関数を使います。
function sum_to(n)
s = 0 # new local
for i = 1:n
s = s + i # assign existing local
end
return s # same local
end前の例と同様に、sum_to の先頭にある s への最初の代入によって、関数本体に新しいローカル変数 s が作られます。for ループは、関数スコープの内側に独自のローカルスコープを持ちます。s = s + i が実行される時点では、s はすでにローカル変数なので、新しいローカル変数を作るのではなく、既存の s を更新します。REPLで sum_to を呼び出して確かめてみましょう。
julia> function sum_to(n)
s = 0 # new local
for i = 1:n
s = s + i # assign existing local
end
return s # same local
end
sum_to (generic function with 1 method)
julia> sum_to(10)
55
julia> s # global
ERROR: UndefVarError: `s` not defined in `Main`s は関数 sum_to のローカル変数なので、関数を呼び出してもグローバル変数 s には影響しません。また、for ループ内の更新 s = s + i が、初期化 s = 0 で作られたものと同じ s を更新したことも分かります。1から10までの整数の合計として正しい55が得られるためです。
for ループ本体が独自のスコープを持つ点をもう少し詳しく見てみましょう。少し冗長な変形版を sum_to_def と呼ぶことにします。この例では、合計 s + i を変数 t に保存してから、s を更新します。
julia> function sum_to_def(n)
s = 0 # new local
for i = 1:n
t = s + i # new local `t`
s = t # assign existing local `s`
end
return s, @isdefined(t)
end
sum_to_def (generic function with 1 method)
julia> sum_to_def(10)
(55, false)このバージョンも先ほどと同じく s を返しますが、さらに @isdefined マクロを使い、関数の最も外側のローカルスコープに t という名前のローカル変数が定義されているかどうかを示す真偽値を返します。ご覧のとおり、for ループ本体の外側には t が定義されていません。これもハードスコープの規則によるものです。代入 t はハードスコープを導入する関数内で行われるため、t は代入が現れるローカルスコープ、つまりループ本体の内側で新しいローカル変数になります。同じ名前のグローバル変数 t があったとしても、結果は変わりません。ハードスコープの規則は、グローバルスコープ内のものに影響されないからです。
forループ本体のローカルスコープは、内側の関数のローカルスコープと変わりません。つまり、この例ではループ本体を内側のヘルパー関数の呼び出しとして書き換えても、同じように動作します。
julia> function sum_to_def_closure(n)
function loop_body(i)
t = s + i # new local `t`
s = t # assign same local `s` as below
end
s = 0 # new local
for i = 1:n
loop_body(i)
end
return s, @isdefined(t)
end
sum_to_def_closure (generic function with 1 method)
julia> sum_to_def_closure(10)
(55, false)この例から分かる重要な点は、次のとおりです。
- 内側の関数のスコープは、ほかの入れ子になったローカルスコープと同じです。特に、内側の関数の外側ですでにローカル変数になっている変数に内側の関数で代入すると、外側のローカル変数が更新されます。
- 外側のローカル変数の定義が、その変数を更新する箇所より後にあっても、規則は変わりません。内側のローカル変数の意味を決定する前に、囲んでいるローカルスコープ全体が解析され、そのローカル変数が特定されます。
この設計により、内側の関数にコードを移したり、そこからコードを取り出したりしても、通常は意味が変わりません。そのため、クロージャを使う言語の一般的なイディオムを実現しやすくなっています(do blocks を参照)。
次に、ソフトスコープの規則が関わる、もう少し曖昧なケースを見てみましょう。greet 関数と sum_to_def 関数の本体をソフトスコープのコンテキストに取り出して調べます。まず、greet の本体を、ハードスコープではなくソフトスコープである for ループに入れ、REPLで評価してみましょう。
julia> for i = 1:3
x = "hello" # new local
println(x)
end
hello
hello
hello
julia> x
ERROR: UndefVarError: `x` not defined in `Main`for ループの評価時にグローバル変数 x が定義されていないため、ソフトスコープ規則の最初の条件が適用されます。x は for ループのローカル変数として作られるので、ループの実行後もグローバル変数 x は未定義のままです。次に、sum_to_def の本体をグローバルスコープに取り出し、引数を n = 10 に固定した場合を考えます。
s = 0
for i = 1:10
t = s + i
s = t
end
s
@isdefined(t)このコードは何をするでしょうか。ヒント:これはひっかけ問題です。答えは「場合による」です。このコードを対話的に入力すると、関数本体内と同じように動作します。しかし、ファイル内に書かれている場合は、曖昧さに関する警告が表示され、未定義変数エラーが発生します。まずはREPLでの動作を見てみましょう。
julia> s = 0 # global
0
julia> for i = 1:10
t = s + i # new local `t`
s = t # assign global `s`
end
julia> s # global
55
julia> @isdefined(t) # global
falseREPLでは、ループ内の代入がグローバル変数に代入するか、新しいローカル変数を作るかを、同じ名前のグローバル変数が定義されているかどうかで判断します。該当するグローバル変数があれば、それを更新します。なければ、新しいローカル変数を作ります。この例では、どちらのケースも確認できます。
tという名前のグローバル変数はないため、t = s + iによって、forループのローカル変数tが新しく作られます。sという名前のグローバル変数があるため、s = tはその変数に代入します。
2つ目の点により、ループを実行するとグローバル変数 s の値が変わります。一方、1つ目の点により、ループの実行後も t は未定義のままです。では、同じコードをファイル内にあるものとして評価してみましょう。
julia> code = """
s = 0 # global
for i = 1:10
t = s + i # new local `t`
s = t # new local `s` with warning
end
s, # global
@isdefined(t) # global
""";
julia> include_string(Main, code)
┌ Warning: Assignment to `s` in soft scope is ambiguous because a global variable by the same name exists: `s` will be treated as a new local. Disambiguate by using `local s` to suppress this warning or `global s` to assign to the existing global variable.
└ @ string:4
ERROR: LoadError: UndefVarError: `s` not defined in local scopeここでは include_string を使い、code をファイルの内容であるかのように評価します。code をファイルに保存し、そのファイルに対して include を呼び出しても、同じ結果になります。ご覧のとおり、REPLで同じコードを評価した場合とは動作が大きく異なります。何が起きているのか、順に見ていきましょう。
- ループの評価前に、グローバル変数
sが値0で定義されています。 - 代入
s = tはソフトスコープ内、つまり関数本体やほかのハードスコープ構文の外にあるforループ内で行われます。 - そのため、ソフトスコープ規則の2つ目の条件が適用されます。代入は曖昧なので、警告が表示されます。
- 実行は続行され、
sはforループ本体のローカル変数になります。 sはforループのローカル変数なので、t = s + iの評価時には未定義となり、エラーが発生します。- そこで評価は停止しますが、
sと@isdefined(t)まで実行されていれば、0とfalseが返されます。
この例は、スコープに関する重要な点を示しています。あるスコープ内では、各変数が持てる意味は1つだけであり、その意味は式の順序にかかわらず決まります。ループ内に式 s = t があるため、s はループのローカル変数になります。そのため、t = s + i の右辺に現れる場合もローカル変数です。右辺の式は先に書かれ、先に評価されますが、それでも変わりません。ループの1行目にある s はグローバル変数で、2行目の s はローカル変数だと考えることもできそうですが、それは不可能です。2行は同じスコープブロック内にあり、同じスコープで1つの変数が持てる意味は1つだけだからです。
On Soft Scope
これでローカルスコープの規則はすべて説明しました。この節を終える前に、曖昧なソフトスコープのケースが対話型と非対話型のコンテキストで異なる扱いになる理由を少し説明しておきましょう。考えられる疑問は、次の2つです。
- どこでもREPLと同じ動作にしないのはなぜでしょうか。
- どこでもファイルと同じ動作にしないのはなぜでしょうか。警告も省略できるのではないでしょうか。
Julia 0.6以前では、すべてのグローバルスコープが現在のREPLと同じように動作していました。つまり、関数本体(または let ブロックや内包表記)の外にあるループ(または try/catch、struct 本体)で x = <value> が現れると、x という名前のグローバル変数が定義されているかどうかに基づいて、x をループのローカル変数にするかどうかが決まっていました。この動作は直感的で便利です。関数本体内の動作をできるだけ忠実に再現するからです。特に、関数の動作をデバッグするときに、関数本体とREPLの間でコードを簡単に移動できます。しかし、欠点もあります。まず、動作がかなり複雑です。長年にわたり、多くの人がこの動作に戸惑い、説明も理解も難しいと不満を述べてきました。もっともな指摘です。次に、さらに重大とも言える問題として、大規模なプログラミングに向いていません。次のような短いコードを一か所で見るだけなら、何が起きるかは明らかです。
s = 0
for i = 1:10
s += i
end意図は、既存のグローバル変数 s を変更することに決まっています。それ以外にどういう意味があるでしょうか。しかし、実際のコードがいつも短く明快とは限りません。次のようなコードは、実際のプログラムでよく見られます。
x = 123
# much later
# maybe in a different file
for i = 1:10
x = "hello"
println(x)
end
# much later
# maybe in yet another file
# or maybe back in the first one where `x = 123`
y = x + 234ここでは、どう動作すべきかがはるかに分かりにくくなります。x + "hello" はメソッドエラーなので、x は for ループのローカル変数であることが意図されているように思えます。しかし、実行時の値や、たまたま存在するメソッドを使って変数のスコープを決めることはできません。Julia 0.6以前の動作では、誰かが for ループを先に書いて問題なく動かしていたのに、後から別の人が遠く離れた場所(場合によっては別のファイル)で新しいグローバル変数を追加したために、コードの意味が突然変わり、エラーが表面化したり、さらに悪いことに、気付かないまま誤動作したりする可能性が特に問題です。この種の "spooky action at a distance" は、優れたプログラミング言語の設計で防ぐべきものです。
そこでJulia 1.0では、スコープ規則を簡素化しました。どのローカルスコープでも、まだローカル変数ではない名前への代入は、新しいローカル変数を作るようにしました。これにより、ソフトスコープという概念が完全になくなり、予期しない影響が生じる可能性もなくなりました。ソフトスコープを廃止したことで、多数のバグを発見して修正できました。この選択が正しかったことが裏付けられたのです。そして、みんな大喜び……というわけではありません。そうではなく、次のように書かなければならなくなったことに腹を立てる人もいました。
s = 0
for i = 1:10
global s += i
endここにある global の注釈に気付きましたか。ひどいものです。こんな状況を許容できるはずがありません。とはいえ、この種のトップレベルコードで global を必須にすると、主に2つの問題があります。
- 関数本体内のコードをREPLにコピーしてデバッグするのが不便になります。
globalの注釈を追加し、関数に戻すときにまた削除しなければなりません。 - 初心者は
globalを付けずにこの種のコードを書き、なぜ動かないのか分からなくなります。発生するエラーはsが未定義だというものですが、この間違いをした人にとって、何の助けにもならないようです。
Julia 1.5以降では、REPLやJupyterノートブックなどの対話型コンテキストであれば、global の注釈なしでこのコードが動作します(Julia 0.6と同様です)。一方、ファイルなどの非対話型コンテキストでは、次のような明確な警告が表示されます。
同じ名前のグローバル変数が存在するため、ソフトスコープ内の
sへの代入は曖昧です。sは新しいローカル変数として扱われます。この警告を抑制するにはlocal sを使い、既存のグローバル変数に代入するにはglobal sを使って、曖昧さを解消してください。
これにより、Julia 1.0の動作がもたらす「大規模なプログラミング」の利点を保ちながら、両方の問題に対処できます。グローバル変数が、遠く離れた場所にあるコードの意味に予期しない影響を与えることはありません。REPLではコピー&ペーストによるデバッグができ、初心者も困りません。また、global の注釈を付け忘れたり、ソフトスコープ内で既存のグローバル変数を誤ってローカル変数でシャドーイングしたりした場合(いずれにしても混乱の原因になります)には、明確な警告が表示されます。
この設計の重要な性質として、ファイル内で警告なしに実行されるコードは、新しいREPLでも同じように動作します。逆に、REPLのセッションをファイルに保存したとき、REPLでの動作と異なる場合には警告が表示されます。
Let Blocks
let 文は新しいハードスコープブロックを作り(上記参照)、実行されるたびに新しい変数束縛を導入します。変数はすぐに代入されなくてもかまいません。
julia> var1 = let x
for i in 1:5
(i == 4) && (x = i; break)
end
x
end
4代入では既存の値の格納場所に新しい値を再代入することがありますが、let は常に新しい格納場所を作ります。この違いは通常は重要ではなく、クロージャを通じてスコープの外まで存続する変数の場合にのみ確認できます。let 構文では、カンマ区切りで複数の代入や変数名を指定できます。
julia> x, y, z = -1, -1, -1;
julia> let x = 1, z
println("x: $x, y: $y") # x is local variable, y the global
println("z: $z") # errors as z has not been assigned yet but is local
end
x: 1, y: -1
ERROR: UndefVarError: `z` not defined in local scope代入は順番に評価されます。各右辺は、左辺の新しい変数が導入される前のスコープで評価されます。そのため、let x = x のように書くのは理にかなっています。2つの x 変数は別々の変数であり、個別の記憶領域を持つからです。let の動作が必要になる例を見てみましょう。
julia> Fs = Vector{Any}(undef, 2); i = 1;
julia> while i <= 2
Fs[i] = ()->i
global i += 1
end
julia> Fs[1]()
3
julia> Fs[2]()
3ここでは、変数 i を返すクロージャを2つ作って保存しています。しかし、どちらも同じ変数 i を参照するため、2つのクロージャは同じ動作をします。let を使うと、i に新しい束縛を作れます。
julia> Fs = Vector{Any}(undef, 2); i = 1;
julia> while i <= 2
let i = i
Fs[i] = ()->i
end
global i += 1
end
julia> Fs[1]()
1
julia> Fs[2]()
2begin 構文は新しいスコープを導入しないため、引数なしの let を使って、新しい束縛をすぐには作らずにスコープブロックだけを導入すると便利な場合があります。
julia> let
local x = 1
let
local x = 2
end
x
end
1let は新しいスコープブロックを導入するため、内側のローカル変数 x は、外側のローカル変数 x とは別の変数です。この例は、次のコードと同じです。
julia> let x = 1
let x = 2
end
x
end
1Loops and Comprehensions
ループや comprehensions では、本体のスコープ内で導入された新しい変数は、ループの反復ごとに新しく割り当てられます。これは、ループ本体が let ブロックで囲まれているかのように動作します。次の例で確認できます。
julia> Fs = Vector{Any}(undef, 2);
julia> for j = 1:2
Fs[j] = ()->j
end
julia> Fs[1]()
1
julia> Fs[2]()
2for ループや内包表記の反復変数は、常に新しい変数です。
julia> function f()
i = 0
for i = 1:3
# empty
end
return i
end;
julia> f()
0ただし、反復変数として既存のローカル変数を再利用したい場合もあります。その場合は、キーワード outer を追加すると簡単に実現できます。
julia> function f()
i = 0
for outer i = 1:3
# empty
end
return i
end;
julia> f()
3Constants
変数は、特定の変わらない値に名前を付けるためによく使われます。このような変数には一度だけ値を代入します。この意図は、const キーワードを使ってコンパイラーに伝えられます。
julia> const e = 2.71828182845904523536;
julia> const pi = 3.14159265358979323846;1つの const 文で、複数の変数を宣言できます。
julia> const a, b = 1, 2
(1, 2)const 宣言は、グローバルスコープのグローバル変数にのみ使ってください。グローバル変数の値(あるいは型さえも)がほぼいつでも変わる可能性があるため、グローバル変数を含むコードの最適化はコンパイラーにとって困難です。グローバル変数が変わらない場合は、const 宣言を追加することで、この性能上の問題を解決できます。
ローカル定数はこれとは大きく異なります。コンパイラーはローカル変数が定数かどうかを自動的に判断できるため、ローカル定数の宣言は不要です。実際、現在はサポートされていません。
function キーワードや struct キーワードによって行われるような、特別なトップレベル代入は、デフォルトで定数になります。
const が影響するのは変数の束縛だけです。変数は配列などの可変オブジェクトに束縛されることがあり、そのオブジェクト自体は引き続き変更できます。また、定数として宣言された変数に値を代入しようとした場合、次のような動作になります。
const
keywordを付けずに定数を置き換えようとすると、許可されません。julia> const x = 1.0 1.0 julia> x = 1 ERROR: invalid assignment to constant x. This redefinition may be permitted using the `const` keyword.それ以外の定数の定義は許可されますが、大規模な再コンパイルが発生することがあります。
julia> const y = 1.0 1.0 julia> const y = 2.0 2.0
Julia 1.12より前のバージョンでは、定数の再定義は十分にサポートされていませんでした。同じ型の定数に限って再定義でき、観測可能な誤動作やクラッシュにつながる可能性がありました。Julia 1.12より前のバージョンでは、定数の再定義は強く推奨されません。詳しくは、以前のJuliaバージョンのマニュアルを参照してください。
Typed Globals
定数として宣言するのと同様に、グローバル変数の束縛に対して、型を常に一定に保つよう宣言することもできます。値を代入せずに global x::T という構文で宣言する方法と、代入時に x::T = 123 として宣言する方法があります。
julia> x::Float64 = 2.718
2.718
julia> f() = x
f (generic function with 1 method)
julia> Base.return_types(f)
1-element Vector{Any}:
Float64グローバル変数への代入では、Juliaはまず convert を使って、適切な型への変換を試みます。
julia> global y::Int
julia> y = 1.0
1.0
julia> y
1
julia> y = 3.14
ERROR: InexactError: Int64(3.14)
Stacktrace:
[...]型は具象型でなくてもかまいませんが、抽象型の型注釈では通常、性能上の利点はほとんどありません。
グローバル変数に値が代入されるか、その型が設定されると、束縛の型を変更できなくなります。
julia> x = 1
1
julia> global x::Int
ERROR: cannot set type for global x. It already has a value or is already set to a different type.
Stacktrace:
[...]