Methods

Functionsで説明したように、関数とは、引数のタプルを戻り値に対応付けるオブジェクトです。適切な値を返せない場合は例外をスローします。同じ概念上の関数や演算でも、引数の型によって実装が大きく異なることはよくあります。たとえば、整数同士の加算と浮動小数点数同士の加算は大きく異なり、整数と浮動小数点数の加算もまた別のものです。実装は異なっていても、これらの演算はいずれも「加算」という一般的な概念に属します。したがってJuliaでは、これらの振る舞いはすべて単一のオブジェクト、すなわち+関数に属します。

同じ概念に対するさまざまな実装をスムーズに利用できるように、関数は一度にすべて定義する必要はありません。引数の型と個数の特定の組み合わせに対する振る舞いを指定し、段階的に定義できます。関数が取りうる振る舞いの定義をメソッドと呼びます。これまで紹介したのは、あらゆる型の引数に適用できる単一のメソッドを持つ関数の例だけでした。しかし、メソッド定義のシグネチャには、引数の個数だけでなく型も指定できます。また、複数のメソッド定義を与えることもできます。特定の引数タプルに関数を適用すると、その引数に適用可能なメソッドのうち、最も具体的なものが実行されます。つまり、関数全体の振る舞いは、さまざまなメソッド定義の振る舞いを組み合わせたものです。この組み合わせが適切に設計されていれば、メソッドの実装が大きく異なっていても、関数の外から見た振る舞いは一貫していて、継ぎ目がないように見えます。

関数を適用したときにどのメソッドを実行するかを選ぶ仕組みをディスパッチと呼びます。Juliaでは、与えられた引数の個数と、すべての引数の型に基づいて、呼び出すメソッドを選択できます。これは、最初の引数だけに基づいてディスパッチする従来のオブジェクト指向言語とは異なります。そうした言語では、最初の引数に特別な構文が使われることが多く、引数として明示的に書かずに暗黙に渡される場合もあります。[1] 最初の引数だけでなく、関数のすべての引数を使って呼び出すメソッドを選ぶことを、multiple dispatchと呼びます。数学的なコードでは、複数ディスパッチが特に有用です。演算がほかの引数よりも特定の引数に「属する」と人為的に見なすのは、ほとんど意味がないからです。たとえば、x + yの加算演算は、yよりもxに属すると言えるでしょうか。数学演算の実装は、一般にすべての引数の型に依存します。さらに、数学演算に限らず、複数ディスパッチはプログラムの構造化や整理に役立つ、強力で便利なパラダイムです。

Note

この章の例はすべて、同じモジュール内の関数にメソッドを定義することを前提としています。別のモジュールにある関数へメソッドを追加する場合は、importするか、モジュール名で修飾した名前を使う必要があります。namespace managementの節を参照してください。

Defining Methods

これまでの例では、引数の型に制約のない単一メソッドの関数だけを定義してきました。このような関数は、従来の動的型付け言語での関数と同じように振る舞います。それでも、私たちは意識しないまま、ほぼ常に複数ディスパッチとメソッドを使ってきました。前述の+関数をはじめ、Juliaの標準関数や演算子には、引数の型と個数のさまざまな組み合わせに対する振る舞いを定義するメソッドが多数あります。

関数を定義するときは、::型アサーション演算子を使って、その関数を適用できる引数の型を任意で制約できます。この演算子については、Composite Typesの節で紹介しました。

julia> f(x::Float64, y::Float64) = 2x + y
f (generic function with 1 method)

この関数定義は、xとyがどちらもFloat64型の値である呼び出しにのみ適用されます。

julia> f(2.0, 3.0)
7.0

それ以外の型の引数を渡すと、MethodErrorになります。

julia> f(2.0, 3)
ERROR: MethodError: no method matching f(::Float64, ::Int64)
The function `f` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  f(::Float64, !Matched::Float64)
   @ Main none:1

Stacktrace:
[...]

julia> f(Float32(2.0), 3.0)
ERROR: MethodError: no method matching f(::Float32, ::Float64)
The function `f` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  f(!Matched::Float64, ::Float64)
   @ Main none:1

Stacktrace:
[...]

julia> f(2.0, "3.0")
ERROR: MethodError: no method matching f(::Float64, ::String)
The function `f` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  f(::Float64, !Matched::Float64)
   @ Main none:1

Stacktrace:
[...]

julia> f("2.0", "3.0")
ERROR: MethodError: no method matching f(::String, ::String)
The function `f` exists, but no method is defined for this combination of argument types.

ご覧のとおり、引数は厳密にFloat64型でなければなりません。整数や32ビット浮動小数点数など、ほかの数値型が64ビット浮動小数点数に自動変換されることはなく、文字列が数値として解析されることもありません。Float64は具象型であり、Juliaでは具象型をサブクラス化できないため、この定義を適用できるのは、引数が厳密にFloat64型である場合だけです。ただし、宣言する引数の型を抽象型にして、より汎用的なメソッドを書くと便利なこともよくあります。

julia> f(x::Number, y::Number) = 2x - y
f (generic function with 2 methods)

julia> f(2.0, 3)
1.0

このメソッド定義は、Numberのインスタンスである任意の引数ペアに適用されます。どちらも数値であればよく、同じ型である必要はありません。異なる数値型を扱う処理は、式2x - y内の算術演算に委ねられます。

複数のメソッドを持つ関数を定義するには、引数の個数や型を変えて、その関数を複数回定義します。関数に対する最初のメソッド定義によって関数オブジェクトが作られ、その後のメソッド定義は既存の関数オブジェクトに新しいメソッドを追加します。関数を適用すると、引数の個数と型に一致するメソッド定義のうち、最も具体的なものが実行されます。したがって、上記の2つのメソッド定義を合わせると、抽象型Numberのインスタンスであるすべての引数ペアに対するfの振る舞いが定義されます。ただし、Float64値のペアには、別の振る舞いが適用されます。一方の引数が64ビット浮動小数点数で、もう一方がそうでない場合は、f(Float64,Float64)メソッドを呼び出せないため、より汎用的なf(Number,Number)メソッドが使われます。

julia> f(2.0, 3.0)
7.0

julia> f(2, 3.0)
1.0

julia> f(2.0, 3)
1.0

julia> f(2, 3)
1

2x + y定義が使われるのは最初のケースだけで、それ以外では2x - y定義が使われます。関数の引数が自動的にキャストまたは変換されることはありません。Juliaでの変換はすべて、暗黙の魔法に頼らず、完全に明示的に行われます。ただし、Conversion and Promotionは、十分に高度な技術を巧みに応用すれば、魔法と見分けがつかなくなることを示しています。[Clarke61]

数値以外の値を渡した場合や、引数が2個より少ない、または多い場合、関数fは未定義のままなので、適用するとMethodErrorになります。

julia> f("foo", 3)
ERROR: MethodError: no method matching f(::String, ::Int64)
The function `f` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  f(!Matched::Number, ::Number)
   @ Main none:1
  f(!Matched::Float64, !Matched::Float64)
   @ Main none:1

Stacktrace:
[...]

julia> f()
ERROR: MethodError: no method matching f()
The function `f` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  f(!Matched::Float64, !Matched::Float64)
   @ Main none:1
  f(!Matched::Number, !Matched::Number)
   @ Main none:1

Stacktrace:
[...]

対話セッションで関数オブジェクト自体を入力すると、その関数に存在するメソッドを簡単に確認できます。

julia> f
f (generic function with 2 methods)

この出力から、fが2つのメソッドを持つ関数オブジェクトだと分かります。各メソッドのシグネチャを確認するには、methods関数を使います。

julia> methods(f)
# 2 methods for generic function "f" from Main:
 [1] f(x::Float64, y::Float64)
     @ none:1
 [2] f(x::Number, y::Number)
     @ none:1

この出力から、fには2つのメソッドがあり、一方はFloat64型の引数を2つ取り、もう一方はNumber型の引数を取ることが分かります。また、メソッドが定義されたファイルと行番号も示されます。これらのメソッドはREPLで定義したため、行番号はnone:1と表示されます。

::による型宣言がない場合、メソッドの引数の型はデフォルトでAnyです。Juliaのすべての値は抽象型Anyのインスタンスなので、これは引数の型に制約がないことを意味します。したがって、fに対する、あらゆる引数ペアを受け付けるメソッドを次のように定義できます。

julia> f(x,y) = println("Whoa there, Nelly.")
f (generic function with 3 methods)

julia> methods(f)
# 3 methods for generic function "f" from Main:
 [1] f(x::Float64, y::Float64)
     @ none:1
 [2] f(x::Number, y::Number)
     @ none:1
 [3] f(x, y)
     @ none:1

julia> f("foo", 1)
Whoa there, Nelly.

この汎用メソッドは、引数ペアに対するほかのどのメソッド定義よりも具体性が低いため、ほかに適用可能なメソッド定義がない場合にのみ呼び出されます。

3つ目のメソッドのシグネチャでは、引数xとyの型が指定されていないことに注意してください。これはf(x::Any, y::Any)を短く書いたものです。

単純な概念に見えますが、値の型に基づく複数ディスパッチは、おそらくJulia言語の中核をなす最も強力な機能です。基本的な演算には、通常、数十ものメソッドがあります。

julia> methods(+)
# 180 methods for generic function "+":
[1] +(x::Bool, z::Complex{Bool}) in Base at complex.jl:227
[2] +(x::Bool, y::Bool) in Base at bool.jl:89
[3] +(x::Bool) in Base at bool.jl:86
[4] +(x::Bool, y::T) where T<:AbstractFloat in Base at bool.jl:96
[5] +(x::Bool, z::Complex) in Base at complex.jl:234
[6] +(a::Float16, b::Float16) in Base at float.jl:373
[7] +(x::Float32, y::Float32) in Base at float.jl:375
[8] +(x::Float64, y::Float64) in Base at float.jl:376
[9] +(z::Complex{Bool}, x::Bool) in Base at complex.jl:228
[10] +(z::Complex{Bool}, x::Real) in Base at complex.jl:242
[11] +(x::Char, y::Integer) in Base at char.jl:40
[12] +(c::BigInt, x::BigFloat) in Base.MPFR at mpfr.jl:307
[13] +(a::BigInt, b::BigInt, c::BigInt, d::BigInt, e::BigInt) in Base.GMP at gmp.jl:392
[14] +(a::BigInt, b::BigInt, c::BigInt, d::BigInt) in Base.GMP at gmp.jl:391
[15] +(a::BigInt, b::BigInt, c::BigInt) in Base.GMP at gmp.jl:390
[16] +(x::BigInt, y::BigInt) in Base.GMP at gmp.jl:361
[17] +(x::BigInt, c::Union{UInt16, UInt32, UInt64, UInt8}) in Base.GMP at gmp.jl:398
...
[180] +(a, b, c, xs...) in Base at operators.jl:424

複数ディスパッチと柔軟なパラメトリック型システムを組み合わせることで、Juliaでは実装の詳細から切り離して、高水準アルゴリズムを抽象的に表現できます。

Method specializations

同じ関数に複数のメソッドを作成することを、「特殊化」と呼ぶことがあります。この場合は、関数にメソッドを追加して関数を特殊化しています。新しいメソッドを追加するたびに、その関数の新たな特殊化が作られます。上で示したように、これらの特殊化はmethodsによって返されます。

プログラマーが介入しなくても起こる、別の種類の特殊化もあります。Juliaのコンパイラーは、実際に使われる引数の型に合わせて、メソッドを自動的に特殊化できます。このような特殊化は、methodsには表示されません。新しいMethodが作られるわけではないためです。ただし、@code_typedなどのツールを使えば、こうした特殊化を調べられます。

たとえば、次のメソッドを作成するとします。

mysum(x::Real, y::Real) = x + y

これにより、関数mysumに新しいメソッドが1つ追加されます(これが唯一のメソッドである場合もあります)。このメソッドは、任意のReal型の数値入力を2つ取ります。しかし、次のコードを実行すると、

julia> mysum(1, 2)
3

julia> mysum(1.0, 2.0)
3.0

Juliaはmysumを2回コンパイルします。1回目はx::Int, y::Int用、2回目はx::Float64, y::Float64用です。2回コンパイルするのは、性能を高めるためです。+に対して呼び出されるメソッド(mysumが使うメソッド)は、xとyの具体的な型によって異なります。異なる特殊化をコンパイルしておけば、Juliaはメソッド検索を事前に済ませられます。そのため、実行中にメソッド検索を行う必要がなくなり、プログラムを大幅に高速化できます。Juliaの自動特殊化を利用すれば、汎用的なアルゴリズムを書くだけで、コンパイラーが必要なケースごとに効率的な特殊化コードを生成してくれます。

特殊化の候補数が実質的に無制限になりうる場合、Juliaはデフォルトの特殊化を避けることがあります。詳しくはBe aware of when Julia avoids specializingを参照してください。

Method Ambiguities

関数のメソッドを、ある引数の組み合わせに対して適用可能な最も具体的なメソッドが一意に定まらないように定義することもできます。

julia> g(x::Float64, y) = 2x + y
g (generic function with 1 method)

julia> g(x, y::Float64) = x + 2y
g (generic function with 2 methods)

julia> g(2.0, 3)
7.0

julia> g(2, 3.0)
8.0

julia> g(2.0, 3.0)
ERROR: MethodError: g(::Float64, ::Float64) is ambiguous.

Candidates:
  g(x, y::Float64)
    @ Main none:1
  g(x::Float64, y)
    @ Main none:1

Possible fix, define
  g(::Float64, ::Float64)

Stacktrace:
[...]

この場合、呼び出しg(2.0, 3.0)には、g(::Float64, ::Any)メソッドとg(::Any, ::Float64)メソッドのどちらも適用できます。メソッドを定義した順序は関係なく、どちらかがもう一方より具体的ということもありません。このような場合、Juliaは任意にメソッドを選ぶのではなく、MethodErrorを発生させます。交差するケースに適切なメソッドを指定すれば、メソッドの曖昧さを回避できます。

julia> g(x::Float64, y::Float64) = 2x + 2y
g (generic function with 3 methods)

julia> g(2.0, 3)
7.0

julia> g(2, 3.0)
8.0

julia> g(2.0, 3.0)
10.0

曖昧さを解消するメソッドは、先に定義しておくことをお勧めします。そうしないと、より具体的なメソッドを定義するまでの間、一時的とはいえ曖昧さが存在するためです。

より複雑なケースでは、メソッドの曖昧さを解消するために設計上の工夫が必要になります。このトピックについては、belowでさらに説明します。

Parametric Methods

メソッド定義では、シグネチャを修飾する型パラメーターを任意で指定できます。

julia> same_type(x::T, y::T) where {T} = true
same_type (generic function with 1 method)

julia> same_type(x,y) = false
same_type (generic function with 2 methods)

最初のメソッドは、引数がどの型であるかにかかわらず、両方が同じ具象型であれば適用されます。2つ目のメソッドは、それ以外のすべてのケースを受け付ける汎用メソッドです。したがって、全体として、2つの引数が同じ型かどうかを判定する真偽値関数が定義されます。

julia> same_type(1, 2)
true

julia> same_type(1, 2.0)
false

julia> same_type(1.0, 2.0)
true

julia> same_type("foo", 2.0)
false

julia> same_type("foo", "bar")
true

julia> same_type(Int32(1), Int64(2))
false

このような定義は、型シグネチャがUnionAll型であるメソッドに対応します(UnionAll Typesを参照)。

ディスパッチによって関数の振る舞いを定義するこの方法は、Juliaでは非常によく使われており、慣用的とさえ言えます。メソッドの型パラメーターは、引数の型として使う場合に限られません。関数のシグネチャや本体で、値を使える場所ならどこでも使えます。次の例では、メソッドのシグネチャにあるパラメトリック型Vector{T}の型パラメーターとして、メソッドの型パラメーターTを使っています。

julia> function myappend(v::Vector{T}, x::T) where {T}
           return [v..., x]
       end
myappend (generic function with 1 method)

この例の型パラメーターTにより、追加する要素xが、ベクターvの既存の要素型のサブタイプであることが保証されます。whereキーワードは、メソッドシグネチャの定義の後に、こうした制約のリストを導入します。上の例のような1行定義でも同様に使えます。また、return type declarationがある場合は、次の例のように、その前に置く必要があります。

julia> (myappend(v::Vector{T}, x::T)::Vector) where {T} = [v..., x]
myappend (generic function with 1 method)

julia> myappend([1,2,3],4)
4-element Vector{Int64}:
 1
 2
 3
 4

julia> myappend([1,2,3],2.5)
ERROR: MethodError: no method matching myappend(::Vector{Int64}, ::Float64)
The function `myappend` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  myappend(::Vector{T}, !Matched::T) where T
   @ Main none:1

Stacktrace:
[...]

julia> myappend([1.0,2.0,3.0],4.0)
4-element Vector{Float64}:
 1.0
 2.0
 3.0
 4.0

julia> myappend([1.0,2.0,3.0],4)
ERROR: MethodError: no method matching myappend(::Vector{Float64}, ::Int64)
The function `myappend` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  myappend(::Vector{T}, !Matched::T) where T
   @ Main none:1

Stacktrace:
[...]

追加する要素の型が、追加先のベクターの要素型と一致しない場合は、MethodErrorが発生します。次の例では、メソッドの型パラメーターTを戻り値として使っています。

julia> mytypeof(x::T) where {T} = T
mytypeof (generic function with 1 method)

julia> mytypeof(1)
Int64

julia> mytypeof(1.0)
Float64

型宣言の型パラメーターにサブタイプ制約を付けられるのと同様に(Parametric Typesを参照)、メソッドの型パラメーターにも制約を付けられます。

julia> same_type_numeric(x::T, y::T) where {T<:Number} = true
same_type_numeric (generic function with 1 method)

julia> same_type_numeric(x::Number, y::Number) = false
same_type_numeric (generic function with 2 methods)

julia> same_type_numeric(1, 2)
true

julia> same_type_numeric(1, 2.0)
false

julia> same_type_numeric(1.0, 2.0)
true

julia> same_type_numeric("foo", 2.0)
ERROR: MethodError: no method matching same_type_numeric(::String, ::Float64)
The function `same_type_numeric` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  same_type_numeric(!Matched::T, ::T) where T<:Number
   @ Main none:1
  same_type_numeric(!Matched::Number, ::Number)
   @ Main none:1

Stacktrace:
[...]

julia> same_type_numeric("foo", "bar")
ERROR: MethodError: no method matching same_type_numeric(::String, ::String)
The function `same_type_numeric` exists, but no method is defined for this combination of argument types.

julia> same_type_numeric(Int32(1), Int64(2))
false

same_type_numeric関数は、上で定義したsame_type関数とよく似た振る舞いをしますが、数値のペアに対してのみ定義されています。

パラメトリックメソッドでは、型を書くときに使うwhere式と同じ構文を使えます(UnionAll Typesを参照)。パラメーターが1つだけの場合、囲みの波括弧(where {T})は省略できますが、明確さを優先して付けることもよくあります。複数のパラメーターは、たとえばwhere {T, S<:Real}のようにカンマで区切るか、where S<:Real where Tのようにwhereを入れ子にして書けます。

Redefining Methods

メソッドを再定義したり、新しいメソッドを追加したりしても、その変更がすぐに反映されるわけではないことに注意してください。これは、通常のJITの仕掛けやオーバーヘッドに頼らず、Juliaがコードを静的に推論して高速に実行できるようコンパイルするための重要な仕組みです。実際、新しいメソッド定義は、TaskやThread、以前に定義された@generated関数を含め、現在の実行環境からは見えません。まず例を見て、これがどういう意味か確認しましょう。

julia> function tryeval()
           @eval newfun() = 1
           newfun()
       end
tryeval (generic function with 1 method)

julia> tryeval()
ERROR: MethodError: no method matching newfun()
The applicable method may be too new: running in world age xxxx1, while current world is xxxx2.
Closest candidates are:
  newfun() at none:1 (method too new to be called from this world context.)
 in tryeval() at none:1
 ...

julia> newfun()
1

この例では、newfunの新しい定義が作成されているものの、すぐには呼び出せないことに注目してください。新しいグローバル変数はtryeval関数からすぐに見えるため、括弧なしでreturn newfunと書くことはできます。しかし、あなた自身も、呼び出し元も、その関数が呼び出す関数も、その他のどの関数も、この新しいメソッド定義を呼び出すことはできません。

ただし例外があります。REPLから行うnewfunへの今後の呼び出しでは、新しいnewfunの定義が見え、期待どおりに呼び出せます。

一方、tryevalへの今後の呼び出しでは、newfunの定義は、REPLで直前の文を実行した時点のままです。つまり、その呼び出しでtryevalを呼び出す前の定義が使われます。

実際に試して、動作を確認してみてください。

この動作は「ワールドエイジカウンター」によって実装されています。詳しくは、マニュアルのWorld Ageの章で説明しています。

Design Patterns with Parametric Methods

複雑なディスパッチロジックは、性能や使いやすさのために必須ではありません。しかし、アルゴリズムを表現するうえで最適な方法となることもあります。ここでは、このようなディスパッチを使う際によく見られる設計パターンをいくつか紹介します。

Extracting the type parameter from a super-type

要素型が明確に定義されている任意のAbstractArrayサブタイプについて、その要素型Tを返す正しいコードのひな型は次のとおりです。

abstract type AbstractArray{T, N} end
eltype(::Type{<:AbstractArray{T}}) where {T} = T

これは、いわゆる三角ディスパッチを使っています。たとえばeltype(AbstractArray{T} where T <: Integer)のようなUnionAll型は、上記のメソッドには一致しないことに注意してください。Baseにあるeltypeの実装では、このようなケースに対応するフォールバックメソッドをAnyに追加しています。

よくある間違いの1つは、イントロスペクションを使って要素型を取得しようとすることです。

eltype_wrong(::Type{A}) where {A<:AbstractArray} = A.parameters[1]

しかし、これが失敗するケースを作るのは難しくありません。

struct BitVector <: AbstractArray{Bool, 1}; end

ここでは、パラメーターを持たない型BitVectorを作成しましたが、要素型は完全に指定されています。TはBoolです。

もう1つの間違いは、supertypeを使って型階層をたどろうとすることです。

eltype_wrong(::Type{AbstractArray{T}}) where {T} = T
eltype_wrong(::Type{AbstractArray{T, N}}) where {T, N} = T
eltype_wrong(::Type{A}) where {A<:AbstractArray} = eltype_wrong(supertype(A))

これは宣言型では動作しますが、スーパータイプを持たない型では失敗します。

julia> eltype_wrong(Union{Vector{Int}, Matrix{Int}})
ERROR: MethodError: no method matching supertype(::Type{VecOrMat{Int64}})

Closest candidates are:
  supertype(::UnionAll)
   @ Base operators.jl:44
  supertype(::DataType)
   @ Base operators.jl:43

Building a similar type with a different type parameter

汎用コードを作成する際、型のレイアウトを変更し、それに伴って型パラメーターも変更した、類似のオブジェクトを構築する必要が生じることがよくあります。たとえば、要素型が任意の抽象配列を受け取り、特定の要素型を使って計算を行いたい場合があります。この型変換の方法を定めるメソッドを、AbstractArray{T}のサブタイプごとに実装する必要があります。あるサブタイプを、パラメーターの異なる別のサブタイプへ変換する一般的な方法はありません。

AbstractArrayのサブタイプでは、通常、次の2つのメソッドを実装してこれを実現します。1つは入力配列を特定のAbstractArray{T, N}抽象型のサブタイプに変換するメソッド、もう1つは特定の要素型を持つ未初期化配列を作成するメソッドです。これらの実装例はJulia Baseにあります。次は、inputとoutputが同じ型になることを保証する、基本的な使用例です。

input = convert(AbstractArray{Eltype}, input)
output = similar(input, Eltype)

これを拡張して、アルゴリズムで入力配列のコピーが必要な場合を考えます。convertだけでは、戻り値が元の入力とエイリアスする可能性があるため不十分です。similar(出力配列の作成)とcopyto!(入力データの格納)を組み合わせると、入力引数の変更可能なコピーが必要であることを汎用的に表現できます。

copy_with_eltype(input, Eltype) = copyto!(similar(input, Eltype), input)

Iterated dispatch

複数階層のパラメトリックな引数リストに対してディスパッチするには、各階層のディスパッチを別々の関数に分けるのが最善であることがよくあります。これは単一ディスパッチに似た方法に思えるかもしれませんが、以下で見るように、こちらのほうが柔軟です。

たとえば、配列の要素型に基づいてディスパッチしようとすると、曖昧さが生じることがよくあります。その代わりに、一般的なコードではまずコンテナー型に基づいてディスパッチし、次にeltypeに基づく、より具体的なメソッドへ再帰的に進みます。ほとんどの場合、アルゴリズムはこの階層的な方法に自然に適合しますが、そうでない場合は、この厳密さを手動で解決する必要があります。たとえば、2つの行列を加算する処理には、このようなディスパッチの分岐が見られます。

# First dispatch selects the map algorithm for element-wise summation.
+(a::Matrix, b::Matrix) = map(+, a, b)
# Then dispatch handles each element and selects the appropriate
# common element type for the computation.
+(a, b) = +(promote(a, b)...)
# Once the elements have the same type, they can be added.
# For example, via primitive operations exposed by the processor.
+(a::Float64, b::Float64) = Core.add(a, b)

Trait-based dispatch

上記の段階的なディスパッチを自然に拡張すると、型階層で定義された集合とは独立した型の集合に基づいてディスパッチできるよう、メソッド選択にもう1つの層を加えることができます。対象の型を列挙したUnionを書けば、そのような集合を作れます。しかし、Union型は作成後に変更できないため、この集合は拡張できません。一方、"Holy-trait"と呼ばれることの多い設計パターンを使えば、拡張可能な集合を実装できます。

このパターンでは、関数の引数が属する可能性のある各トレイト集合に対して、異なるシングルトン値(または型)を計算する汎用関数を定義します。この関数が純粋であれば、通常のディスパッチと比べて性能への影響はありません。

前の節の例では、mapとpromoteの実装の詳細を省略しました。どちらも、こうしたトレイトを使って動作します。mapの実装のように行列を走査する場合、データをどの順序でたどるかが重要な問題の1つです。AbstractArrayのサブタイプがBase.IndexStyleトレイトを実装していれば、mapなどの関数はこの情報に基づいてディスパッチし、最適なアルゴリズムを選べます(Abstract Array Interfaceを参照)。つまり、汎用的な定義とトレイトクラスによって最速の実装が選ばれるため、各サブタイプがmapの独自実装を用意する必要はありません。次は、トレイトに基づくディスパッチを示す、mapの簡単な実装例です。

map(f, a::AbstractArray, b::AbstractArray) = map(Base.IndexStyle(a, b), f, a, b)
# generic implementation:
map(::Base.IndexCartesian, f, a::AbstractArray, b::AbstractArray) = ...
# linear-indexing implementation (faster)
map(::Base.IndexLinear, f, a::AbstractArray, b::AbstractArray) = ...

このトレイトベースの方法は、スカラー+が使うpromoteの仕組みにも使われています。この仕組みではpromote_typeを使い、オペランドの2つの型をもとに、演算に適した共通型を返します。これにより、型引数のあらゆる組み合わせに対してすべての関数を実装するという問題を、各型から共通型への変換演算と、型のペアごとに優先する昇格規則の表を実装するという、はるかに小さな問題に置き換えられます。

Output-type computation

トレイトベースの昇格についての説明は、次の設計パターン、すなわち行列演算の出力要素型の計算へとつながります。

加算などの基本演算を実装する際は、promote_type関数を使って、望ましい出力型を計算します。(前述のとおり、+の呼び出しにあるpromoteの呼び出しで、この動作を確認しました。)

行列に対するより複雑な関数では、さらに複雑な一連の演算に対して、期待される戻り値の型を計算する必要がある場合があります。多くの場合、次の手順で行います。

  1. アルゴリズムのカーネルが実行する一連の演算を表す、小さな関数opを書く。
  2. 結果の行列の要素型Rを、promote_op(op, argument_types...)として計算する。ここでargument_typesは、各入力配列にeltypeを適用して求める。
  3. 出力配列の望ましい次元をdimsとして、出力行列をsimilar(R, dims)として構築する。

より具体的な例として、汎用的な正方行列の乗算を擬似コードで書くと、次のようになります。

function matmul(a::AbstractMatrix, b::AbstractMatrix)
    op = (ai, bi) -> ai * bi + ai * bi

    ## this is insufficient because it assumes `one(eltype(a))` is constructable:
    # R = typeof(op(one(eltype(a)), one(eltype(b))))

    ## this fails because it assumes `a[1]` exists and is representative of all elements of the array
    # R = typeof(op(a[1], b[1]))

    ## this is incorrect because it assumes that `+` calls `promote_type`
    ## but this is not true for some types, such as Bool:
    # R = promote_type(ai, bi)

    # this is wrong, since depending on the return value
    # of type-inference is very brittle (as well as not being optimizable):
    # R = Base.return_types(op, (eltype(a), eltype(b)))

    ## but, finally, this works:
    R = promote_op(op, eltype(a), eltype(b))
    ## although sometimes it may give a larger type than desired
    ## it will always give a correct type

    output = similar(b, R, (size(a, 1), size(b, 2)))
    if size(a, 2) > 0
        for j in 1:size(b, 2)
            for i in 1:size(a, 1)
                ## here we don't use `ab = zero(R)`,
                ## since `R` might be `Any` and `zero(Any)` is not defined
                ## we also must declare `ab::R` to make the type of `ab` constant in the loop,
                ## since it is possible that typeof(a * b) != typeof(a * b + a * b) == R
                ab::R = a[i, 1] * b[1, j]
                for k in 2:size(a, 2)
                    ab += a[i, k] * b[k, j]
                end
                output[i, j] = ab
            end
        end
    end
    return output
end

Separate convert and kernel logic

コンパイル時間とテストの複雑さを大幅に減らす方法の1つは、望ましい型への変換処理と計算処理を分離することです。こうすると、コンパイラーは大きなカーネル本体とは独立して、変換処理を特殊化してインライン化できます。

これは、より広い型の集合から、アルゴリズムが実際にサポートする特定の引数型へ変換する際によく使われるパターンです。

complexfunction(arg::Int) = ...
complexfunction(arg::Any) = complexfunction(convert(Int, arg))

matmul(a::T, b::T) = ...
matmul(a, b) = matmul(promote(a, b)...)

Parametrically-constrained Varargs methods

関数パラメーターを使うと、「可変長引数」関数(Varargs Functions)に渡せる引数の個数も制約できます。このような制約を示すには、Vararg{T,N}という表記を使います。たとえば、次のようになります。

julia> bar(a,b,x::Vararg{Any,2}) = (a,b,x)
bar (generic function with 1 method)

julia> bar(1,2,3)
ERROR: MethodError: no method matching bar(::Int64, ::Int64, ::Int64)
The function `bar` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  bar(::Any, ::Any, ::Any, !Matched::Any)
   @ Main none:1

Stacktrace:
[...]

julia> bar(1,2,3,4)
(1, 2, (3, 4))

julia> bar(1,2,3,4,5)
ERROR: MethodError: no method matching bar(::Int64, ::Int64, ::Int64, ::Int64, ::Int64)
The function `bar` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  bar(::Any, ::Any, ::Any, ::Any)
   @ Main none:1

Stacktrace:
[...]

より実用的な例として、パラメーターを使って可変長引数メソッドを制約できます。たとえば、次のメソッドは、

function getindex(A::AbstractArray{T,N}, indices::Vararg{Number,N}) where {T,N}

indicesの個数が配列の次元数と一致する場合にのみ呼び出されます。

渡された引数の型だけを制約する場合は、Vararg{T}をT...と同じ意味で書けます。たとえば、f(x::Int...) = xはf(x::Vararg{Int}) = xの省略形です。

Note on Optional and keyword Arguments

Functionsで簡単に触れたように、省略可能な引数は複数のメソッド定義を表す構文として実装されています。たとえば、次の定義は、

f(a=1,b=2) = a+2b

次の3つのメソッドに展開されます。

f(a,b) = a+2b
f(a) = f(a,2)
f() = f(1,2)

つまり、f()を呼び出すことは、f(1,2)を呼び出すことと同じです。この場合、結果は5です。これは、f(1,2)が上記のfの最初のメソッドを呼び出すためです。ただし、常にそうなるとは限りません。整数に対してより具体的な4つ目のメソッドを定義すると、

f(a::Int,b::Int) = a-2b

f()とf(1,2)のどちらを呼び出しても、結果は-3になります。つまり、省略可能な引数は特定のメソッドではなく、関数に結び付いています。どのメソッドが呼び出されるかは、省略可能な引数の型によって決まります。省略可能な引数をグローバル変数で定義している場合は、その引数の型が実行時に変わることさえあります。

キーワード引数は、通常の位置引数とは大きく異なる振る舞いをします。特に、メソッドのディスパッチには関与しません。メソッドは位置引数だけに基づいて選択され、キーワード引数は一致するメソッドが特定された後に処理されます。

既知のバグ:キーワード引数の有無がディスパッチに影響する

長年存在するバグ(#9498)により、キーワード引数を指定した呼び出しでは、キーワード引数を受け付けるメソッドだけが候補になります。その結果、キーワード引数を受け付けない、より具体的なメソッドではなく、具体性の低いメソッドが選ばれることがあります。

julia> f(x; y=10) = "generic";

julia> f(x::Int) = "int-specific";

julia> f(1)
"int-specific"

julia> f(1; y=2)  # bug: bypasses the more specific method
"generic"

関連する問題として、キーワード引数のないメソッドを再定義しても、位置引数のシグネチャが同じ以前の定義におけるキーワード引数の処理は置き換わりません。それでも、表示されるメソッドは1つだけです。

julia> g(x; y=1) = "with keywords";

julia> g(x) = "without keywords";

julia> g
g (generic function with 1 method)

julia> g(1)
"without keywords"

julia> g(1; y=2)  # bug: calls the overwritten definition
"with keywords"

この警告は現状の説明であり、この動作を推奨するものではありません。コードでこの動作に依存しないでください。キーワード引数を使う呼び出しにも特殊化したメソッドを適用できるようにするには、キーワード引数を繰り返し指定するか、kwargs...ですべてのキーワード引数を受け取るなどして、そのメソッド独自のキーワードインターフェースを用意してください。

Function-like objects

メソッドは型に関連付けられているため、任意のJuliaオブジェクトの型にメソッドを追加すれば、そのオブジェクトを「呼び出し可能」にできます。

たとえば、多項式の係数を格納しながら、多項式を評価する関数のように振る舞う型を定義できます。

julia> struct Polynomial{R}
           coeffs::Vector{R}
       end

julia> function (p::Polynomial)(x)
           v = p.coeffs[end]
           for i = (length(p.coeffs)-1):-1:1
               v = v*x + p.coeffs[i]
           end
           return v
       end

julia> (p::Polynomial)() = p(5)

関数は名前ではなく型で指定されていることに注目してください。通常の関数と同様に、簡潔な構文も使えます。関数本体では、pが呼び出されたオブジェクトを指します。Polynomialは次のように使えます。

julia> poly = Polynomial([1,10,100])
Polynomial{Int64}([1, 10, 100])

julia> poly(3)
931

julia> poly()
2551

この仕組みは、型コンストラクターやクロージャ(周囲の環境を参照する内部関数)がJuliaでどのように動作するかを理解するうえでも重要です。

Empty generic functions

メソッドをまだ追加せずに、汎用関数だけを導入したい場合があります。これは、インターフェースの定義と実装を分離するために使えます。また、ドキュメントやコードの可読性を高める目的で行うこともあります。この場合は、引数タプルを伴わない空のfunctionブロックを使います。

function emptyfunc end

Method design and the avoidance of ambiguities

Juliaのメソッド多相性は、最も強力な機能の1つです。しかし、その力を活用するには設計上の課題が伴うことがあります。特に、複雑なメソッド階層では、ambiguitiesが発生するのは珍しくありません。

先ほど、次のような曖昧さは、

f(x, y::Int) = 1
f(x::Int, y) = 2

次のメソッドを定義すれば解消できると説明しました。

f(x::Int, y::Int) = 3

これは多くの場合、適切な方法です。しかし、この助言に何も考えず従うと逆効果になる状況もあります。特に、汎用関数のメソッドが増えるほど、曖昧さが生じる可能性も高まります。メソッド階層がこの単純な例より複雑になったら、別の解決策も慎重に検討する価値があります。

以下では、具体的な課題と、それを解決するための別の方法を説明します。

Tuple and NTuple arguments

Tuple(およびNTuple)の引数には、特有の課題があります。たとえば、

f(x::NTuple{N,Int}) where {N} = 1
f(x::NTuple{N,Float64}) where {N} = 2

これらはN == 0の可能性があるため、曖昧になります。要素がないので、IntとFloat64のどちらを呼び出すべきか判断できません。曖昧さを解消する方法の1つは、空のタプルに対するメソッドを定義することです。

f(x::Tuple{}) = 3

別の方法として、1つを除くすべてのメソッドで、タプルに要素が少なくとも1つあることを要求できます。

f(x::NTuple{N,Int}) where {N} = 1           # this is the fallback
f(x::Tuple{Float64, Vararg{Float64}}) = 2   # this requires at least one Float64

Orthogonalize your design

2つ以上の引数に基づくディスパッチを考えている場合は、「ラッパー」関数を使うと設計が簡潔になるかどうか検討してください。たとえば、複数のバリエーションを書く代わりに、

f(x::A, y::A) = ...
f(x::A, y::B) = ...
f(x::B, y::A) = ...
f(x::B, y::B) = ...

次のように定義する方法があります。

f(x::A, y::A) = ...
f(x, y) = f(g(x), g(y))

ここでgは、引数をA型に変換します。これは、別々の概念を別々のメソッドに割り当てるorthogonal designという、より一般的な原則の具体例です。この場合、gには、おそらく次のようなフォールバック定義が必要です。

g(x::A) = x

関連する方法として、promoteを使い、xとyを共通の型に変換する方法があります。

f(x::T, y::T) where {T} = ...
f(x, y) = f(promote(x, y)...)

この設計にはリスクもあります。xとyを同じ型に変換する適切な昇格メソッドがない場合、2つ目のメソッドが自分自身を無限に再帰的に呼び出し、スタックオーバーフローを引き起こす可能性があります。

Dispatch on one argument at a time

複数の引数に基づいてディスパッチする必要があり、フォールバックの組み合わせが多すぎて、考えられるすべてのバリエーションを定義するのが現実的でない場合は、「名前のカスケード」を導入する方法を検討してください。たとえば、最初の引数に基づいてディスパッチし、その後、内部メソッドを呼び出します。

f(x::A, y) = _fA(x, y)
f(x::B, y) = _fB(x, y)

こうすると、内部メソッド_fAと_fBは、xに関して互いに曖昧になる心配なく、yに基づいてディスパッチできます。

ただし、この方法には少なくとも1つ大きな欠点があります。多くの場合、ユーザーはエクスポートされた関数fに新たな特殊化を定義して、fの振る舞いをさらにカスタマイズすることができません。その代わりに、内部メソッド_fAと_fBに特殊化を定義する必要があり、エクスポートされたメソッドと内部メソッドの境界が曖昧になります。

Abstract containers and element types

可能であれば、抽象コンテナーの特定の要素型に基づいてディスパッチするメソッドは定義しないようにしてください。たとえば、

-(A::AbstractArray{T}, b::Date) where {T<:Date}

この定義は、次のメソッドを定義する人にとって曖昧さの原因になります。

-(A::MyArrayType{T}, b::T) where {T}

最善の方法は、これらのメソッドをどちらも定義しないことです。その代わりに、汎用メソッド-(A::AbstractArray, b)に頼り、このメソッドが、コンテナー型と要素型それぞれに適切な動作をする汎用呼び出し(similarや-など)を使って実装されていることを確認してください。これは、メソッドをorthogonalizeするという助言を、より複雑な形で適用したものです。

この方法が使えない場合は、ほかの開発者と曖昧さの解消について話し合う価値があります。先に定義されたメソッドだからといって、変更や削除ができないとは限りません。最後の手段として、開発者の1人が次の「応急処置」メソッドを定義し、

-(A::MyArrayType{T}, b::Date) where {T<:Date} = ...

力ずくで曖昧さを解消することもできます。

Complex method "cascades" with default arguments

デフォルト値を与えるメソッドの「カスケード」を定義する場合、デフォルト値に対応する引数を省略しないよう注意してください。たとえば、信号の端をパディングして処理するデジタルフィルタリングアルゴリズムを書くとします。

function myfilter(A, kernel, ::Replicate)
    Apadded = replicate_edges(A, size(kernel))
    myfilter(Apadded, kernel)  # now perform the "real" computation
end

このメソッドは、パディングのデフォルト値を与える次のメソッドと衝突します。

myfilter(A, kernel) = myfilter(A, kernel, Replicate()) # replicate the edge by default

この2つのメソッドを組み合わせると、Aが際限なく大きくなりながら無限再帰を起こします。

より適切な設計では、呼び出し階層を次のように定義します。

struct NoPad end  # indicate that no padding is desired, or that it's already applied

myfilter(A, kernel) = myfilter(A, kernel, Replicate())  # default boundary conditions

function myfilter(A, kernel, ::Replicate)
    Apadded = replicate_edges(A, size(kernel))
    myfilter(Apadded, kernel, NoPad())  # indicate the new boundary conditions
end

# other padding methods go here

function myfilter(A, kernel, ::NoPad)
    # Here's the "real" implementation of the core computation
end

NoPadは、ほかの種類のパディングと同じ引数位置に指定されるため、ディスパッチ階層を整理しやすく、曖昧さも生じにくくなります。さらに、「公開」インターフェースであるmyfilterも拡張されます。パディングを明示的に制御したいユーザーは、NoPadのバリエーションを直接呼び出せます。

Defining methods in local scope

local scope内でメソッドを定義できます。たとえば、次のように書けます。

julia> function f(x)
           g(y::Int) = y + x
           g(y) = y - x
           g
       end
f (generic function with 1 method)

julia> h = f(3);

julia> h(4)
7

julia> h(4.0)
1.0

ただし、次のように、条件付きや制御フローの中でローカルメソッドを定義してはいけません。

function f2(inc)
    if inc
        g(x) = x + 1
    else
        g(x) = x - 1
    end
end

function f3()
    function g end
    return g
    g() = 0
end

どの関数が最終的に定義されるのかが明確でないためです。将来的には、このようなローカルメソッドの定義がエラーになる可能性があります。

このような場合は、代わりに無名関数を使ってください。

function f2(inc)
    g = if inc
        x -> x + 1
    else
        x -> x - 1
    end
end
  • 1たとえばC++やJavaでは、obj.meth(arg1,arg2)のようなメソッド呼び出しにおいて、オブジェクトobjがメソッド呼び出しを「受け取り」、thisキーワードを介して暗黙にメソッドへ渡されます。現在のthisオブジェクトがメソッド呼び出しの受け手である場合は、そのオブジェクトを省略してmeth(arg1,arg2)とだけ書けます。このとき、受け手のオブジェクトはthisであると暗黙に解釈されます。
  • Clarke61Arthur C. Clarke, Profiles of the Future(1961年):クラークの第三法則。