Type Inference(型推論)

• Go back to TOP(インデックスページへ)
• Basic Literals
• Array Literals
• Dictionary Literals
• Ternary Expression
• Functions
• Ambiguities

変数または定数の宣言で明示的に型が注釈(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}

翻訳元->https://cadence-lang.org/docs/language/type-inference

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

Previous << Type Safety

Next >> Composite Types