Conversion and Promotion

Julia には、数学演算子の引数を共通の型に昇格させる仕組みがあります。この仕組みについては、Integers and Floating-Point Numbers、Mathematical Operations and Elementary Functions、Types、Methods など、ほかの節でも触れてきました。この節では、この昇格の仕組みがどのように動作するかに加え、新しい型への拡張方法や、組み込みの数学演算子以外の関数への適用方法を説明します。従来、算術演算の引数の昇格に関して、プログラミング言語は次の2つの流派に分かれています。

  • 組み込みの算術型と演算子に対して自動的に昇格を行う。 ほとんどの言語では、組み込みの数値型を +、-、*、/ などの中置構文の算術演算子のオペランドとして使うと、期待される結果を得るために、共通の型へ自動的に昇格されます。たとえば C、Java、Perl、Python はいずれも、+ のオペランドの一方が整数であっても、和 1 + 1.5 を浮動小数点値 2.5 として正しく計算します。このような仕組みは便利で、十分に注意深く設計されているため、通常、プログラマーがその存在を意識することはほとんどありません。このような式を書くときに昇格が行われることを意識する人はほぼいませんが、整数と浮動小数点値はそのままでは加算できないため、コンパイラやインタープリターは加算の前に変換を行う必要があります。そのため、このような自動変換に関する複雑な規則は、必然的にこれらの言語の仕様と実装の一部になります。
  • 自動的な昇格を行わない。 こちらには、非常に「厳格な」静的型付け言語である Ada や ML が含まれます。これらの言語では、プログラマーがすべての変換を明示的に指定しなければなりません。したがって、例の式 1 + 1.5 は、Ada と ML のどちらでもコンパイルエラーになります。代わりに real(1) + 1.5 と書き、加算を行う前に整数 1 を浮動小数点値に明示的に変換する必要があります。ただし、あらゆる箇所で明示的な変換を行うのはあまりに不便なため、Ada にもある程度の自動変換があります。整数リテラルは期待される整数型に自動的に昇格され、浮動小数点リテラルも同様に適切な浮動小数点型に昇格されます。

ある意味では、Julia は「自動的な昇格を行わない」言語に分類されます。数学演算子は特別な構文を持つ単なる関数であり、関数の引数が自動的に変換されることは決してありません。しかし、さまざまな型が混在する引数に数学演算を適用することは、多相的な多重ディスパッチの極端な一例にすぎないともいえます。そして、Julia のディスパッチシステムと型システムは、まさにそのような処理を得意としています。数学演算のオペランドの「自動」昇格は、その特別な応用として実現されます。Julia には、オペランドの型の組み合わせに対応する具体的な実装が存在しない場合に呼び出される、数学演算子用の汎用的なディスパッチ規則があらかじめ用意されています。これらの汎用規則は、まずユーザーが定義できる昇格規則を使ってすべてのオペランドを共通の型に昇格させ、次に、同じ型になった値に対して、その演算子の特化した実装を呼び出します。ユーザー定義型も、ほかの型との相互変換用メソッドと、ほかの型と混在したときにどの型へ昇格させるかを定める少数の昇格規則を定義するだけで、この昇格の仕組みに簡単に組み込めます。

Conversion

ある型 T の値を得る標準的な方法は、その型のコンストラクター T(x) を呼び出すことです。しかし、プログラマーが明示的に要求しなくても、ある型の値を別の型に変換できると便利な場合があります。その一例が、配列への値の代入です。A が Vector{Float64} である場合、式 A[1] = 2 は、2 を Int から Float64 に自動的に変換し、その結果を配列に格納することで動作するべきです。この処理には convert 関数が使われます。

convert 関数は通常、2つの引数を取ります。第1引数は型オブジェクト、第2引数はその型に変換する値です。戻り値は、指定した型のインスタンスに変換された値です。この関数を理解するには、実際の動作を見るのが一番簡単です。

julia> x = 12
12

julia> typeof(x)
Int64

julia> xu = convert(UInt8, x)
0x0c

julia> typeof(xu)
UInt8

julia> xf = convert(AbstractFloat, x)
12.0

julia> typeof(xf)
Float64

julia> a = Any[1 2 3; 4 5 6]
2×3 Matrix{Any}:
 1  2  3
 4  5  6

julia> convert(Array{Float64}, a)
2×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0

変換は常に可能とは限りません。変換できない場合は、convert が要求された変換の方法を知らないことを示す MethodError がスローされます。

julia> convert(AbstractFloat, "foo")
ERROR: MethodError: Cannot `convert` an object of type String to an object of type AbstractFloat
[...]

文字列を数値として解析することや、数値を文字列として整形することを、変換とみなす言語もあります。多くの動的言語では、そのような変換が自動的に行われることさえあります。Julia ではそうではありません。数値として解析できる文字列もありますが、ほとんどの文字列は数値の有効な表現ではなく、有効なのはごく限られた一部だけです。そのため Julia では、この操作には専用の parse 関数を使う必要があり、操作がより明示的になります。

When is convert called?

次の言語構文は convert を呼び出します。

  • 配列への代入では、配列の要素型に変換します。
  • オブジェクトのフィールドへの代入では、そのフィールドで宣言された型に変換します。
  • new によるオブジェクトの構築では、オブジェクトの各フィールドで宣言された型に変換します。
  • 型が宣言された変数(例:local x::T)への代入では、その型に変換します。
  • 戻り値の型が宣言された関数では、戻り値をその型に変換します。
  • ccall に値を渡すと、対応する引数の型に変換します。

Conversion vs. Construction

convert(T, x) の動作は、T(x) とほぼ同じに見えることに注意してください。実際、通常は同じです。しかし、意味の上では重要な違いがあります。convert は暗黙的に呼び出される可能性があるため、そのメソッドは「安全」または「予想外のことが起きない」とみなせる場合に限られます。convert が変換を行うのは、基本的に同じ種類のものを表す型同士だけです。たとえば、数値の異なる表現同士や、異なる文字列エンコーディング同士が該当します。また、通常は情報の損失もありません。値を別の型に変換してから元の型に戻すと、まったく同じ値になるはずです。

コンストラクターが convert と異なる場合は、大きく4種類あります。

Constructors for types unrelated to their arguments

「変換」という概念を実装していないコンストラクターもあります。たとえば、Timer(2) は2秒のタイマーを作成しますが、これは整数からタイマーへの「変換」とはいえません。

Mutable collections

x がすでに T 型である場合、convert(T, x) は元の x を返すことが期待されます。一方、T が可変なコレクション型であれば、T(x) は常に新しいコレクションを作成するべきです。その際、x から要素をコピーします。

Wrapper types

ほかの値を「ラップする」型では、引数がすでに要求された型であっても、コンストラクターがその引数を新しいオブジェクトでラップすることがあります。たとえば Some(x) は、結果が Some または nothing になり得る文脈で、値が存在することを示すために x をラップします。しかし、x 自体がオブジェクト Some(y) である場合もあります。その場合、結果は二重にラップされた Some(Some(y)) になります。一方、convert(Some, x) は、x がすでに Some であるため、そのまま返します。

Constructors that don't return instances of their own type

ごくまれに、コンストラクター T(x) が T 型ではないオブジェクトを返すことが妥当な場合もあります。たとえば、ラッパー型が自分自身の逆操作になっている場合(Flip(Flip(x)) === x など)や、ライブラリの再構成時に後方互換性のために古い呼び出し構文をサポートする場合です。しかし、convert(T, x) は常に T 型の値を返すべきです。

Defining New Conversions

新しい型を定義する際は、まず、その型の値を作成する方法をすべてコンストラクターとして定義するべきです。暗黙的な変換が有用であり、一部のコンストラクターが上記の「安全性」の基準を満たすと明らかになったら、convert メソッドを追加できます。これらのメソッドは適切なコンストラクターを呼び出すだけでよいため、通常は非常に単純です。たとえば、次のように定義できます。

import Base: convert
convert(::Type{MyType}, x) = MyType(x)

このメソッドの第1引数の型は Type{MyType} であり、その唯一のインスタンスは MyType です。したがって、このメソッドが呼び出されるのは、第1引数が型の値 MyType である場合だけです。第1引数に使われている構文に注目してください。:: 記号の前の引数名が省略され、型だけが指定されています。これは Julia において、型は指定するものの、値を名前で参照する必要がない関数引数に使う構文です。

一部の抽象型では、そのすべてのインスタンスがデフォルトで「十分に似ている」とみなされ、Julia Base に汎用的な convert の定義が用意されています。たとえば、次の定義は、引数を1つ取るコンストラクターを呼び出すことで、任意の Number 型から別の同種の型への convert が有効であることを示しています。

convert(::Type{T}, x::Number) where {T<:Number} = T(x)::T

つまり、新しい Number 型では、コンストラクターを定義するだけで十分です。この定義が convert を処理してくれるためです。引数がすでに要求された型である場合に対応するため、恒等変換も用意されています。

convert(::Type{T}, x::T) where {T<:Number} = x

AbstractString、AbstractArray、AbstractDict にも同様の定義があります。

Promotion

昇格とは、異なる型が混在する値を、単一の共通の型に変換することです。厳密には必須ではありませんが、通常は、変換先の共通の型で元の値をすべて忠実に表現できることが含意されています。この意味で、値が「より大きな」型、つまりすべての入力値を単一の共通の型で表現できる型に変換されるため、「昇格」という用語は適切です。ただし、これをオブジェクト指向の(構造的な)上位型の関係や、Julia における抽象上位型の概念と混同しないことが重要です。昇格は型階層とはまったく関係がなく、異なる表現の間の変換に関するものです。たとえば、Int32 の値はすべて Float64 の値としても表現できますが、Int32 は Float64 のサブタイプではありません。

Julia では、共通の「より大きな」型への昇格は promote 関数によって行われます。この関数は任意の個数の引数を取り、共通の型に変換した同じ個数の値をタプルとして返します。昇格が不可能な場合は例外をスローします。昇格の最も一般的な用途は、数値引数を共通の型に変換することです。

julia> promote(1, 2.5)
(1.0, 2.5)

julia> promote(1, 2.5, 3)
(1.0, 2.5, 3.0)

julia> promote(2, 3//4)
(2//1, 3//4)

julia> promote(1, 2.5, 3, 3//4)
(1.0, 2.5, 3.0, 0.75)

julia> promote(1.5, im)
(1.5 + 0.0im, 0.0 + 1.0im)

julia> promote(1 + 2im, 3//4)
(1//1 + 2//1*im, 3//4 + 0//1*im)

浮動小数点値は、引数に含まれる浮動小数点型のうち、最も大きい型に昇格されます。整数値は、引数に含まれる整数型のうち、最も大きい型に昇格されます。型のサイズが同じで符号の有無が異なる場合は、符号なしの型が選ばれます。整数と浮動小数点値が混在している場合は、すべての値を保持できる十分な大きさの浮動小数点型に昇格されます。整数と有理数が混在している場合は有理数に昇格されます。有理数と浮動小数点数が混在している場合は浮動小数点数に昇格されます。複素数値と実数値が混在している場合は、適切な種類の複素数値に昇格されます。

昇格の使い方は、実際のところこれだけです。あとは工夫して応用するだけであり、その最も典型的な例が、算術演算子 +、-、*、/ などの数値演算に対する汎用メソッドの定義です。promotion.jl にある汎用メソッドの定義をいくつか示します。

+(x::Number, y::Number) = +(promote(x,y)...)
-(x::Number, y::Number) = -(promote(x,y)...)
*(x::Number, y::Number) = *(promote(x,y)...)
/(x::Number, y::Number) = /(promote(x,y)...)

これらのメソッド定義は、2つの数値の加算、減算、乗算、除算について、より具体的な規則がない場合には、値を共通の型に昇格してから再試行することを意味します。必要なのはそれだけです。それ以外の箇所で、算術演算のために共通の数値型への昇格を気にする必要は一切ありません。昇格は自動的に行われます。promotion.jl には、ほかにも多数の算術関数や数学関数に対する汎用的な昇格メソッドの定義がありますが、それ以外では、Julia Base で promote を呼び出す必要はほとんどありません。promote が最もよく使われるのは、利便性のために用意される外部コンストラクターメソッドです。これにより、異なる型が混在するコンストラクター呼び出しで、フィールドを適切な共通の型に昇格させてから、内部の型の構築に委譲できます。たとえば、rational.jl では、次の外部コンストラクターメソッドが用意されていました。

Rational(n::Integer, d::Integer) = Rational(promote(n,d)...)

これにより、次のような呼び出しが動作します。

julia> x = Rational(Int8(15),Int32(-5))
-3//1

julia> typeof(x)
Rational{Int32}

ほとんどのユーザー定義型では、コンストラクター関数に期待される型の値をプログラマーが明示的に渡すようにする方がよい設計です。しかし、特に数値を扱う問題では、自動的に昇格を行うと便利な場合もあります。

Defining Promotion Rules

原理的には promote 関数のメソッドを直接定義することもできますが、その場合、引数の型のあらゆる並びに対して、多くの冗長な定義が必要になります。そこで、promote の動作は、promote_rule という補助関数を使って定義されており、この補助関数のメソッドを追加できます。promote_rule 関数は2つの型オブジェクトを取り、別の型オブジェクトを返します。引数の型のインスタンスは、この戻り値の型に昇格されます。したがって、次の規則を定義すると、

import Base: promote_rule
promote_rule(::Type{Float64}, ::Type{Float32}) = Float64

64ビットと32ビットの浮動小数点値を一緒に昇格させる場合、64ビット浮動小数点型に昇格させることを宣言したことになります。昇格先の型は、引数の型のいずれかである必要はありません。たとえば、次の2つの昇格規則はどちらも Julia Base に存在します。

promote_rule(::Type{BigInt}, ::Type{Float64}) = BigFloat
promote_rule(::Type{BigInt}, ::Type{Int8}) = BigInt

後者では、結果の型は BigInt になります。任意精度整数演算で使う整数を保持できる十分な大きさを持つ型は、BigInt だけだからです。また、promote_rule(::Type{A}, ::Type{B}) と promote_rule(::Type{B}, ::Type{A}) の両方を定義する必要はないことにも注意してください。昇格処理における promote_rule の使われ方によって、対称性が自動的に得られます。

promote_rule 関数は、promote_type という別の関数を定義するための構成要素として使われます。この関数は、任意の個数の型オブジェクトを受け取り、それらの型の値を promote の引数に渡したときに昇格される共通の型を返します。したがって、実際の値がなくても、特定の型を持つ一連の値がどの型に昇格されるかを知りたい場合は、promote_type を使えます。

julia> promote_type(Int8, Int64)
Int64

promote_type を直接オーバーロードするのではないことに注意してください。代わりに promote_rule をオーバーロードします。promote_type は promote_rule を使い、対称性を追加します。これを直接オーバーロードすると、曖昧性エラーが発生する可能性があります。どのように昇格させるかを定義するには promote_rule をオーバーロードし、その結果を調べるには promote_type を使います。

内部では、promote の中で promote_type が使われ、昇格のために引数の値をどの型に変換するかを決定します。興味がある方は、promotion.jl のコードを読んでみてください。昇格の仕組み全体が約35行で定義されています。

Case Study: Rational Promotions

最後に、これまで取り上げてきた Julia の有理数型の事例を締めくくります。この型は、次の昇格規則によって、昇格の仕組みを比較的高度に活用しています。

import Base: promote_rule
promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
promote_rule(::Type{Rational{T}}, ::Type{Rational{S}}) where {T<:Integer,S<:Integer} = Rational{promote_type(T,S)}
promote_rule(::Type{Rational{T}}, ::Type{S}) where {T<:Integer,S<:AbstractFloat} = promote_type(T,S)

最初の規則は、有理数をほかの任意の整数型とともに昇格させると、分子・分母の型が、元の分子・分母の型と相手の整数型を昇格させた結果になっている有理数型に昇格されることを示します。2番目の規則は、異なる2つの有理数型に同じ考え方を適用します。その結果、それぞれの分子・分母の型を昇格させた型を使う有理数になります。3番目の最後の規則は、有理数を浮動小数点数とともに昇格させると、分子・分母の型をその浮動小数点数とともに昇格させた場合と同じ型になることを定めています。

この少数の昇格規則と、その型のコンストラクター、数値用のデフォルトの convert メソッドがあれば、有理数は Julia のほかのすべての数値型、つまり整数、浮動小数点数、複素数と、ごく自然に相互運用できます。同じように適切な変換メソッドと昇格規則を用意すれば、どのようなユーザー定義の数値型でも、Julia の定義済みの数値型と同様に自然に相互運用できます。