Type Inference(型推論)

Previous << Type Safety
Next >> Composite Types

変数または定数の宣言で明示的に型が注釈(annotate)されていない場合、宣言での型は初期値から推測されます。

Basic Literals

10進整数リテラルおよび16進リテラルは、Int型と推測されます。

let a = 1
/* `a` has type `Int` */

let b = -45
/* `b` has type `Int` */

let c = 0x02
/* `c` has type `Int` */

符号なし固定小数点リテラルは、UFix64型と推測されます。符号付き固定小数点リテラルは、Fix64型と推測されます。

let a = 1.2
/* `a` has type `UFix64` */

let b = -1.2
/* `b` has type `Fix64` */

同様に、他の基本的なリテラルについては、以下の方法で型が推論されます。

Literal Kind	Example	Inferred Type (x)
String literal	let x = "hello"	String
Boolean literal	let x = true	Bool
Nil literal	let x = nil	Never?

Array Literals

配列リテラルはリテラルの要素に基づいて推論され、可変長となります。推論された要素の型は、すべての要素の最共通する(the least common)スーパータイプ です。

let integers = [1, 2]
/* `integers` has type `[Int]` */

let int8Array = [Int8(1), Int8(2)]
/* `int8Array` has type `[Int8]` */

let mixedIntegers = [UInt(65), 6, 275, Int128(13423)]
/* `mixedIntegers` has type `[Integer]` */

let nilableIntegers = [1, nil, 2, 3, nil]
/* `nilableIntegers` has type `[Int?]` */

let mixed = [1, true, 2, false]
/* `mixed` has type `[AnyStruct]` */

Dictionary Literals

ディクショナリリテラルは、リテラルのキーと値に基づいて推論されます。キーと値の推論された型は、それぞれすべてのキーと値に最共通するスーパータイプ です。

let booleans = {
    1: true,
    2: false
}
/* `booleans` has type `{Int: Bool}` */

let mixed = {
    Int8(1): true,
    Int64(2): "hello"
}
/* `mixed` has type `{Integer: AnyStruct}` */

/* Invalid: mixed keys */
let invalidMixed = {
    1: true,
    false: 2
}
/* The least common super-type of the keys is `AnyStruct`.
   But it is not a valid type for dictionary keys. */

Ternary Expression

3項式は、2番目と3番目のオペランドに最共通するスーパータイプであると推測される。

let a = true ? 1 : 2
/* `a` has type `Int` */

let b = true ? 1 : nil
/* `b` has type `Int?` */

let c = true ? 5 : (false ? "hello" : nil)
/* `c` has type `AnyStruct` */

Functions

関数は、パラメータの型と戻り値の型に基づいて推論されます。

let add = (a: Int8, b: Int8): Int {
    return a + b
}

/* `add` has type `fun(Int8, Int8): Int` */

型推論は各式/文に対して行われ、文全体に対しては行われません。

Ambiguities

型が推論できない場合もあります。このような場合は、明示的なtype annotationが必要です。

/* Invalid: not possible to infer type based on array literal's elements. */
let array = []

/* Instead, specify the array type and the concrete element type, e.g. `Int`. */
let array: [Int] = []

/* Or, use a simple-cast to annotate the expression with a type. */
let array = [] as [Int]

/* Invalid: not possible to infer type based on dictionary literal's keys and values. */
let dictionary = {}

/* Instead, specify the dictionary type and the concrete key
 * and value types, e.g. `String` and `Int`.
 */
let dictionary: {String: Int} = {}

/* Or, use a simple-cast to annotate the expression with a type. */
let dictionary = {} as {String: Int}

翻訳元

---

Previous << Type Safety

Flow BlockchainのCadence version1.0ドキュメント (Type Inference)

Next >> Composite Types