Scoped Values

Scoped valueは、Juliaにおける動的スコープの実装を提供します。

レキシカルスコープと動的スコープ

Lexical scoping はJuliaのデフォルトの動作です。レキシカルスコープでは、変数のスコープはプログラムのレキシカル(テキスト上の)構造によって決まります。一方、動的スコープでは、プログラムの実行中に最後に代入された値が変数に束縛されます。

Scoped valueの状態は、プログラムの実行経路によって変わります。そのため、Scoped valueでは、複数の異なる値を同時に観測することがあります。

Julia 1.11

Scoped valueはJulia 1.11で導入されました。Julia 1.8以降では、パッケージScopedValues.jlを使って互換性のある実装を利用できます。

最も簡単な使い方では、デフォルト値を指定して ScopedValue を作成し、with または @with を使って新しい動的スコープに入ります。新しいスコープは親スコープ(および、さらに外側にあるすべてのスコープ)の値を引き継ぎ、指定したScoped valueの値が以前の定義より優先されます。

まず、レキシカルスコープの例を見てみましょう。let 文は新しいレキシカルスコープを開始し、その中では外側で定義された x が内側の定義によって隠されます。

julia> x = 1
1

julia> let x = 5
           @show x
       end;
x = 5

julia> @show x;
x = 1

次の例では、Juliaがレキシカルスコープを使うため、f の本体にある変数 x は、グローバルスコープで定義された x を参照します。そのため、let スコープに入っても、f が観測する値は変わりません。

julia> x = 1
1

julia> f() = @show x
f (generic function with 1 method)

julia> let x = 5
           f()
       end;
x = 1

julia> f();
x = 1

ここで ScopedValue を使うと、動的スコープを利用できます。

julia> using Base.ScopedValues

julia> x = ScopedValue(1)
ScopedValue{Int64}(1)

julia> f() = @show x[]
f (generic function with 1 method)

julia> with(x=>5) do
           f()
       end;
x[] = 5

julia> f();
x[] = 1

ScopedValue の観測値は、プログラムの実行経路によって変わることに注意してください。

const 変数でScoped valueを参照するのが適切な場合がよくあります。また、1回の with 呼び出しで、複数の ScopedValue の値を設定できます。

using Base.ScopedValues

f() = @show a[]
g() = @show b[]

const a = ScopedValue(1)
const b = ScopedValue(2)

f() # a[] = 1
g() # b[] = 2

# Enter a new dynamic scope and set value.
with(a => 3) do
    f() # a[] = 3
    g() # b[] = 2
    with(a => 4, b => 5) do
        f() # a[] = 4
        g() # b[] = 5
    end
    f() # a[] = 3
    g() # b[] = 2
end

f() # a[] = 1
g() # b[] = 2

ScopedValues は、with のマクロ版です。式 @with var=>val expr は、新しい動的スコープで expr を評価し、そのスコープでは var に val が設定されます。@with var=>val expr は with(var=>val) do expr end と同等です。ただし、with では引数を取らないクロージャまたは関数が必要となり、その分、呼び出しフレームが1つ増えます。例として、次の関数 f を考えてみましょう。

using Base.ScopedValues
const a = ScopedValue(1)
f(x) = a[] + x

f を、a に 2 を設定した動的スコープで実行するには、with を使います。

with(() -> f(10), a=>2)

ただし、この方法では f を引数なし関数でラップする必要があります。呼び出しフレームの増加を避けたい場合は、@with マクロを使えます。

@with a=>2 f(10)
Note

動的スコープは、Task の作成時点で、そのタスクに引き継がれます。Distributed.jl 操作を通じて動的スコープが伝播することはありません。

次の例では、タスクを起動する前に新しい動的スコープを開きます。親タスクと2つの子タスクは、同じScoped valueについて、それぞれ独立した値を同時に観測します。

using Base.ScopedValues
import Base.Threads: @spawn

const scoped_val = ScopedValue(1)
@sync begin
    with(scoped_val => 2)
        @spawn @show scoped_val[] # 2
    end
    with(scoped_val => 3)
        @spawn @show scoped_val[] # 3
    end
    @show scoped_val[] # 1
end

Scoped valueの値はスコープ内では一定ですが、Scoped valueに可変状態を格納することもできます。ただし、並行プログラミングでは、グローバル変数に関する通常の注意点が当てはまることを忘れないでください。

Scoped valueに可変状態への参照を格納する場合にも注意が必要です。新しい動的スコープに入る際に、明示的に unshare mutable state したほうがよい場合があります。

using Base.ScopedValues
import Base.Threads: @spawn

const sval_dict = ScopedValue(Dict())

# Example of using a mutable value wrongly
@sync begin
    # `Dict` is not thread-safe the usage below is invalid
    @spawn (sval_dict[][:a] = 3)
    @spawn (sval_dict[][:b] = 3)
end

@sync begin
    # If we instead pass a unique dictionary to each
    # task we can access the dictionaries race free.
    with(sval_dict => Dict()) do
        @spawn (sval_dict[][:a] = 3)
    end
    with(sval_dict => Dict()) do
        @spawn (sval_dict[][:b] = 3)
    end
end

Example

次の例では、Scoped valueを使ってWebアプリケーションの権限チェックを実装します。リクエストの権限を判定した後、新しい動的スコープに入り、Scoped value LEVEL に値を設定します。アプリケーションの他の部分からScoped valueを参照すると、適切な値を取得できます。タスクローカルストレージやグローバル変数などの方法は、この種の値の伝播には適していません。代わりに使える方法は、呼び出しチェーン全体を通じて値を渡すことだけでした。

using Base.ScopedValues

const LEVEL = ScopedValue(:GUEST)

function serve(request, response)
    level = isAdmin(request) ? :ADMIN : :GUEST
    with(LEVEL => level) do
        Threads.@spawn handle(request, response)
    end
end

function open(connection::Database)
    level = LEVEL[]
    if level !== :ADMIN
        error("Access disallowed")
    end
    # ... open connection
end

function handle(request, response)
    # ...
    open(Database(#=...=#))
    # ...
end

Idioms

Unshare mutable state

using Base.ScopedValues
import Base.Threads: @spawn

const sval_dict = ScopedValue(Dict())

# If you want to add new values to the dict, instead of replacing
# it, unshare the values explicitly. In this example we use `merge`
# to unshare the state of the dictionary in parent scope.
@sync begin
    with(sval_dict => merge(sval_dict[], Dict(:a => 10))) do
        @spawn @show sval_dict[][:a]
    end
    @spawn sval_dict[][:a] = 3 # Not a race since they are unshared.
end

Scoped values as globals

Scoped valueの値にアクセスするには、Scoped value自体が(レキシカル)スコープ内にある必要があります。そのため、多くの場合、Scoped valueは定数のグローバル変数として使うのがよいでしょう。

using Base.ScopedValues
const sval = ScopedValue(1)

実際、Scoped valueは隠れた関数引数と考えることができます。

グローバル変数以外の用途に使えないわけではありません。

using Base.ScopedValues
import Base.Threads: @spawn

function main()
    role = ScopedValue(:client)

    function launch()
        #...
        role[]
    end

    @with role => :server @spawn launch()
    launch()
end

ただし、こうした場合は、関数の引数を直接渡すほうが簡単だったかもしれません。

Very many ScopedValues

あるモジュールで ScopedValue を多数作成する場合は、それらをまとめて保持する専用の構造体を使うほうがよいでしょう。

using Base.ScopedValues

Base.@kwdef struct Configuration
    color::Bool = false
    verbose::Bool = false
end

const CONFIG = ScopedValue(Configuration(color=true))

@with CONFIG => Configuration(color=CONFIG[].color, verbose=true) begin
    @show CONFIG[].color # true
    @show CONFIG[].verbose # true
end

API docs

Base.ScopedValues.AbstractScopedValue — Type
AbstractScopedValue{T}

動的スコープをまたいで値を伝播させる、スコープ付き値の抽象基底型です。すべてのスコープ付き値型は、この抽象型を継承する必要があります。

関連項目: ScopedValue、LazyScopedValue

Julia 1.13

AbstractScopedValue を使用するには、Julia 1.13 以降が必要です。

source
Base.ScopedValues.ScopedValue — Type
ScopedValue(x)

動的スコープ間で値を伝播するコンテナーを作成します。新しい動的スコープを作成して入るには、withを使用します。

値を設定できるのは、新しい動的スコープに入るときだけです。参照される値は、動的スコープの実行中は一定です。

動的スコープはタスク間で伝播します。

Examples

julia> using Base.ScopedValues;

julia> const sval = ScopedValue(1);

julia> sval[]
1

julia> with(sval => 2) do
           sval[]
       end
2

julia> sval[]
1
Julia 1.11

スコープ付き値は Julia 1.11 で導入されました。Julia 1.8 以降では、ScopedValues.jl パッケージから互換実装を利用できます。

source
Base.ScopedValues.LazyScopedValue — Type
LazyScopedValue{T}(f::OncePerProcess{T})

現在のスコープで値が設定されていない場合に、OncePerProcess{T}を使ってデフォルト値を遅延計算するスコープ付きの値です。ScopedValueとは異なり、デフォルト値は構築時には評価されず、初めてアクセスされたときにのみ評価されます。

Examples

julia> using Base.ScopedValues;

julia> const editor = LazyScopedValue(OncePerProcess(() -> ENV["JULIA_EDITOR"]));

julia> editor[]
"vim"

julia> with(editor => "emacs") do
           sval[]
       end
"emacs"

julia> editor[]
"vim"
Julia 1.13

LazyScopedValueにはJulia 1.13以降が必要です。

source
Base.ScopedValues.with — Function
with(f, (var::ScopedValue{T} => val)...)

varをvalに設定して、fを新しい動的スコープで実行します。valはT型に変換されます。

関連項目: ScopedValues.@with、ScopedValues.ScopedValue、ScopedValues.get。

Examples

julia> using Base.ScopedValues

julia> a = ScopedValue(1);

julia> f(x) = a[] + x;

julia> f(10)
11

julia> with(a=>2) do
           f(10)
       end
12

julia> f(10)
11

julia> b = ScopedValue(2);

julia> g(x) = a[] + b[] + x;

julia> with(a=>10, b=>20) do
           g(30)
       end
60

julia> with(() -> a[] * b[], a=>3, b=>4)
12
source
Base.ScopedValues.@with — Macro
@with (var::ScopedValue{T} => val)... expr

withのマクロ版です。式@with var=>val exprは、新しい動的スコープ内でexprを評価し、その際varにはvalが設定されます。valは型Tに変換されます。@with var=>val exprはwith(var=>val) do expr endと同等ですが、@withではクロージャが作成されません。

関連項目: ScopedValues.with、ScopedValues.ScopedValue、ScopedValues.get。

Examples

julia> using Base.ScopedValues

julia> const a = ScopedValue(1);

julia> f(x) = a[] + x;

julia> @with a=>2 f(10)
12

julia> @with a=>3 begin
           x = 100
           f(x)
       end
103
source
Base.ScopedValues.get — Function
get(val::ScopedValue{T})::Union{Nothing, Some{T}}
get(val::LazyScopedValue{T})::Union{Nothing, Some{T}}

スコープ内の値が設定されておらず、デフォルト値もない場合は、nothingを返します。それ以外の場合は、現在の値を含むSome{T}を返します。

関連項目: ScopedValues.with、ScopedValues.@with、ScopedValues.ScopedValue。

Examples

julia> using Base.ScopedValues

julia> a = ScopedValue(42); b = ScopedValue{Int}();

julia> ScopedValues.get(a)
Some(42)

julia> isnothing(ScopedValues.get(b))
true
source

Implementation notes and performance

Scope は永続辞書を使います。検索と挿入は O(log(32, n)) であり、動的スコープに入る際には少量のデータだけがコピーされ、変更されていないデータは他のスコープと共有されます。

Scope オブジェクト自体はユーザー向けのものではなく、Juliaの将来のバージョンで変更される可能性があります。

Design inspiration

この設計は JEPS-429 に大きな影響を受けています。これはさらに、多くのLisp方言における動的スコープの自由変数に着想を得たものです。特に、Interlisp-Dとそのディープバインディング方式が参考になっています。

以前には、PEPS-567 のようなコンテキスト変数を使う設計も議論され、Juliaでは ContextVariablesX.jl として実装されていました。