Type Inference(型推論)

[Previous << Type Safety](https://qiita.com/flowcadence/items/48303ea74f8e783d9d06)
[Next >> Composite Types](https://qiita.com/flowcadence/items/d15aeb14b6bbddd9e717)

https://qiita.com/flowcadence/items/3073d69c6e9895e68b5a#cadenceの言語仕様を学ぶ

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

<h1 id="Basic-Literals">Basic Literals</h1>

10進整数リテラルおよび16進リテラルは、`Int`型と推測されます。
```ruby
let a = 1
/* `a` has type `Int` */

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

let c = 0x02
/* `c` has type `Int` */
```
符号なし固定小数点リテラルは、`UFix64`型と推測されます。符号付き固定小数点リテラルは、`Fix64`型と推測されます。
```ruby
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? |

<h1 id="Array-Literals">Array Literals</h1>

配列リテラルはリテラルの要素に基づいて推論され、可変長となります。推論された要素の型は、すべての要素の*最共通する(the least common)スーパータイプ* です。
```ruby
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]` */
```


<h1 id="Dictionary-Literals">Dictionary Literals</h1>

ディクショナリリテラルは、リテラルのキーと値に基づいて推論されます。キーと値の推論された型は、それぞれすべてのキーと値に*最共通するスーパータイプ* です。
```ruby
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. */
```

<h1 id="Ternary-Expression">Ternary Expression</h1>

3項式は、2番目と3番目のオペランドに最共通するスーパータイプであると推測される。
```ruby
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` */
```

<h1 id="Functions">Functions</h1>

関数は、パラメータの型と戻り値の型に基づいて推論されます。
```ruby
let add = (a: Int8, b: Int8): Int {
    return a + b
}

/* `add` has type `fun(Int8, Int8): Int` */
```
型推論は各式/文に対して行われ、文全体に対しては行われません。

<h1 id="Ambiguities">Ambiguities</h1>

型が推論できない場合もあります。このような場合は、明示的なtype annotationが必要です。
```ruby
/* 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]
```
```ruby
/* 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

***
<b>[Previous << Type Safety](https://qiita.com/flowcadence/items/48303ea74f8e783d9d06)
</b>

[Flow blockchain / Cadence version1.0ドキュメント](https://qiita.com/flowcadence/items/3073d69c6e9895e68b5a) (Type Inference)

<b>[Next >> Composite Types](https://qiita.com/flowcadence/items/d15aeb14b6bbddd9e717)</b>