型変換

let y: i64 = i64::from(x);

let x: i32 = 10;
let a: i64 = i64::from(x); // 失敗しない変換（From）
let b: i64 = x.into();     // Intoは自動で実装される

let big: i64 = 3_000_000_000;
let c: Result<i32, _> = i32::try_from(big); // Err（範囲外）
let d = big as i32;                          // 黙って切り捨てられる

let n: Result<i32, _> = "42".parse::<i32>(); // 文字列 -> 数値もResult

`From`は失敗しない変換、`TryFrom`は失敗し得る変換にのみ実装され、変換の安全性が型で区別される。一方で`as`は縮小変換でも黙って値を切り捨てるため、失敗を見逃す抜け道が残っている。melangの「変換をinterfaceで定義し、失敗し得るものは`Result`で返す」方針の主な参考元。

let y = x.to_int64()

let x : Int = 10
let y : Int64 = x.to_int64()
let z : Double = x.to_double()
let s : String = x.to_string()

`to_int64()`, `to_double()`のような変換メソッドを型ごとに持つ。文字列のパースなど失敗し得る変換は、エラーとして表される。melangの記法に近く、エラーを型で表す設計思想も近い。

let y = Int64(x)

let x: Int32 = 10
let y = Int64(x)

let big: Int64 = 3_000_000_000
let a = Int32(big)            // 範囲外だと実行時にクラッシュ
let b = Int32(exactly: big)   // 範囲外ならnil
let c = Int32(truncatingIfNeeded: big) // 切り捨てを明示

let n: Int? = Int("42") // 文字列 -> 数値は失敗するとnil

変換は`Int64(x)`のように型名のイニシャライザで書く。範囲外の値は実行時にクラッシュさせ、失敗を許容する場合は`exactly:`付きのイニシャライザでOptionalを返す。「クラッシュ / nil / 切り捨て」を引数ラベルで書き分ける点は参考になるが、失敗の理由を持たないOptionalで表す。

val y = x.toLong()

val x: Int = 10
val y: Long = x.toLong()

val big: Long = 3_000_000_000
val z: Int = big.toInt() // 黙って切り捨てられる

val a: Int? = "42".toIntOrNull()   // 失敗するとnull
val b: Int = "abc".toInt()          // NumberFormatException

数値変換は`toLong()`, `toInt()`のようなメソッドで書き、melangの記法と最も近い。文字列のパースには例外を投げる`toInt()`と、失敗時にnullを返す`toIntOrNull()`があり、名前で失敗の扱いを区別している。ただしnullは失敗の理由を持たず、`Long.toInt()`のような数値の縮小変換は失敗を検出しない。

int y = (int) x;

long big = 3_000_000_000L;
int a = (int) big; // 黙って切り捨てられる
int b = Math.toIntExact(big); // 範囲外ならArithmeticException

int n = Integer.parseInt("42");
int m = Integer.parseInt("abc"); // NumberFormatException

Number num = 10;
long l = num.longValue(); // メソッド形式の変換もある

基本はキャスト構文で、縮小変換は黙って値を切り捨てる。範囲外を検出したい場合は`Math.toIntExact`のような別のAPIを選ぶ必要がある。文字列のパースは`parseInt`が検査例外ではない`NumberFormatException`を投げるため、失敗可能性がシグネチャに現れない。

val y = x.toLong

val x: Int = 10
val y: Long = x.toLong

val big: Long = 3000000000L
val z: Int = big.toInt // 黙って切り捨てられる

val a: Option[Int] = "42".toIntOption // 失敗するとNone
val b: Int = "abc".toInt              // NumberFormatException

Kotlinと同様に`toLong`, `toInt`のメソッド形式で数値変換を書く。文字列のパースには例外を投げる`toInt`と`Option`を返す`toIntOption`があり、`Try`や`Either`で包んで失敗を値として扱うこともできる。

int y = (int) x;

long big = 3_000_000_000;
int a = (int) big;            // 既定では黙って値が変わる
int b = checked((int) big);   // OverflowException

int n = int.Parse("42");
int m = int.Parse("abc");     // FormatException

if (int.TryParse("abc", out int v)) {
    // 成功したときだけvが使える
}

失敗し得る変換に`TryParse`という名前を付け、`bool`と`out`引数で成功・失敗を返す慣習が古くからある。`try`を名前に含めて失敗可能性をコード上に示す点はmelangと同じ発想。ただし`bool`は失敗の理由を持たず、`out`引数のため書き方も冗長になる。数値のキャストは既定で検査されない。

long y = static_cast<long>(x);

int x = 10;
long y = static_cast<long>(x);
short s = static_cast<short>(70000); // 黙って値が変わる

int n = std::stoi("42");     // 失敗すると例外
int m = std::stoi("abc");    // std::invalid_argument

// 例外を使わない場合
int v;
auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), v);
if (ec != std::errc()) { /* 失敗 */ }

`static_cast`や`reinterpret_cast`など、変換の性質ごとに分かれたキャスト構文を持つ。数値のキャストは失敗を検出しない。文字列からのパースは`std::stoi`が例外、`std::from_chars`がエラーコードで失敗を表し、方式が混在している。

long y = (long) x;

int x = 10;
long y = (long) x;
short s = (short) 70000; // 黙って値が変わる（結果は実装定義）

char *end;
long n = strtol("42", &end, 10);
long m = strtol("abc", &end, 10); // endがstrの先頭のまま。errnoの確認も必要

int bad = atoi("abc"); // 失敗しても0が返り、正当な0と区別できない

`(Type)`によるキャスト構文がC++の`static_cast`などの直接の起源であり、数値の縮小変換は検出されず黙って値が変わる。文字列のパースは、失敗と「0という正当な結果」を区別できない`atoi`のような関数と、`errno`とポインタ引数の両方を確認しないと失敗を検出できない`strtol`のような関数が混在しており、失敗を安全に扱う統一的な言語機能を欠いたまま、各ライブラリ関数が独自の規約で失敗を表している。

y := int64(x)

var x int32 = 10
y := int64(x) // 型名を使った明示的な変換

var big int64 = 3_000_000_000
z := int32(big) // 黙って切り捨てられる

n, err := strconv.Atoi("42")
if err != nil {
    // 失敗
}

数値型間の変換は`T(x)`の形で、縮小変換でも失敗を検出せず値を切り捨てる。文字列からのパースは`strconv`パッケージの関数が`(値, error)`を返し、呼び出し側が`err`を確認する。失敗を返り値で表す点はmelangの`Result`に近いが、確認を忘れてもコンパイルは通る。

const y: i64 = @intCast(x);

const x: i32 = 10;
const y: i64 = @intCast(x); // 拡大方向の変換

const big: i64 = 3_000_000_000;
const z: i32 = @intCast(big);   // 範囲外だとDebug/ReleaseSafeで実行時panic
const w: i32 = @truncate(big);  // 切り捨てを明示するbuiltin

const n: i32 = try std.fmt.parseInt(i32, "42", 10); // 失敗は!i32のエラーユニオン

`@intCast`, `@floatCast`, `@truncate`, `@ptrCast`のようなbuiltin関数で変換を明示する。数値の縮小変換は安全性チェック付きビルド（Debug/ReleaseSafe）では範囲外の値を実行時panicとして検出し（ReleaseFast/ReleaseSmallでは未定義動作）、切り捨てを許容したい場合は`@truncate`を使い分ける。文字列のパースなど失敗し得る変換は`std.fmt.parseInt`のようにerror union（`!T`）を返す関数で表現し、`try`で伝播するか`catch`で処理する。C由来の暗黙の数値変換はほとんどなく、comptime-known値やpeer type resolutionによる限定的なcoercionを除けば変換は明示のbuiltinを介する。

let y = Int64.of_int x

let x : int = 10
let y : int64 = Int64.of_int x
let f : float = float_of_int x

let a : int option = int_of_string_opt "42"  (* Some 42 *)
let b : int = int_of_string "abc"            (* Failure "int_of_string" *)

`Int64.of_int`, `float_of_int`のように、変換元と変換先の組ごとに専用の関数を持つ。文字列のパースは例外を投げる`int_of_string`と、`option`を返す`int_of_string_opt`があり、名前の接尾辞で失敗の扱いを区別する。

let y : int64 = int64 x

let x : int32 = 10
let y : int64 = int64 x  // 組み込みの変換演算子

let big : int64 = 3_000_000_000L
let z : int32 = int32 big  // 黙って切り捨てられる

let ok, n = System.Int32.TryParse("42")
// F#がout引数をタプルの戻り値に変換して見せる

OCamlの`Int64.of_int`のような個別関数ではなく、`int`, `int64`, `float`のような組み込みの変換演算子を持ち、C言語風のキャストに近い書き味になっている。数値の縮小変換はC++やJavaと同様に黙って値を切り捨てる。.NET標準の`TryParse`（`bool`と`out`引数）は、F#コンパイラソースコードを解析し、実行可能な形式（機械語や中間表現）に変換するプログラム。静的型付け言語では、実行前にコンパイラが型の不整合などをチェックする役割も担う。が`out`引数を戻り値のタプルへ自動変換して見せるため、C#より扱いやすい形でパターンマッチできる。

y = fromIntegral x :: Int64

x :: Int32
x = 10

y :: Int64
y = fromIntegral x        -- 数値型間の変換

z :: Int32
z = fromIntegral (3000000000 :: Int64) -- 黙って溢れる

toIntegralSized (3000000000 :: Int64) :: Maybe Int32 -- Nothing

readMaybe "42" :: Maybe Int -- Just 42

数値型間の変換は`fromIntegral`が担い、縮小変換でも黙って値が溢れる。範囲外を検出したい場合は`toIntegralSized`が`Maybe`を返す。文字列のパースは、例外を投げる`read`より失敗を`Maybe`で表す`readMaybe`が推奨されている。

integer_to_list(X)

integer_to_list(42).   %% "42"
list_to_integer("42"). %% 42
list_to_integer("abc"). %% badarg でプロセスが異常終了

try list_to_integer("abc") of
    N -> N
catch
    error:badarg -> 0
end.

`integer_to_list/1`, `list_to_integer/1`のような組み込み関数（BIF）で変換する。失敗すると`badarg`のようなエラーで即座にプロセスが終了する「let it crash」が基本方針で、必要な箇所だけ`try`/`catch`で捕捉する。Elixirの`{:ok, value}`のような値としての失敗表現は、Erlang標準ライブラリの慣習としては薄い。

Integer.to_string(x)

Integer.to_string(42)   # "42"
trunc(3.9)               # 3

Integer.parse("42")      # {42, ""}
Integer.parse("abc")     # :error

String.to_integer("abc") # ArgumentError

`Integer.parse/1`は成功時に`{値, 残りの文字列}`、失敗時に`:error`を返し、パターンマッチで扱える。一方`String.to_integer/1`は失敗時に例外を投げる。Elixirでは`{:ok, value}`のようなタプルで結果を表す慣習があり、melangの`Result`に近い考え方。

const n = Number(s);

const s: string = "42";
const n: number = Number(s);
const t: string = n.toString();

Number("abc");  // NaN（型はnumberのまま）
parseInt("abc"); // NaN

const v = s as unknown as number; // 型を偽るだけで値は変換されない

`Number(x)`や`x.toString()`で実行時に変換する。失敗は`NaN`になり、型はnumberのままなので失敗可能性が型に現れない。`as`は型検査器への申告にすぎず、実行時には何も変換しない点も、変換と混同しやすい。

const n = Number(s);

Number("42");    // 42
Number("abc");   // NaN
parseInt("42px"); // 42（途中まで読める）
(10).toString(); // "10"

BigInt(1.5);     // RangeError

`Number("abc")`は`NaN`、`parseInt("42px")`は先頭の数字だけを読んで`42`を返すなど、失敗や部分的な成功が値の中に紛れ込む。`BigInt(1.5)`のように例外で失敗する変換もあり、失敗の表現が統一されていない。

$n = (int) $s;

$n = (int) "42";     // 42
$m = (int) "abc";    // 0（失敗を隠す）
$k = (int) "12abc";  // 12（途中まで読む）

filter_var("abc", FILTER_VALIDATE_INT); // false
filter_var("42", FILTER_VALIDATE_INT);  // 42

`(int)`キャストは変換に失敗しても`0`を返すなど、失敗を通常の値として扱う。失敗を検出したい場合は`filter_var`のような別の関数を使い、失敗は`false`で返る。成功した`0`と失敗を区別するには呼び出し側の注意が必要になる。

n = s.to_i

"42".to_i     # 42
"abc".to_i    # 0（失敗を隠す）
"12abc".to_i  # 12

Integer("abc")                    # ArgumentError
Integer("abc", exception: false)  # nil
42.to_s       # "42"

`to_i`, `to_s`, `to_f`のメソッド形式で変換するが、`to_i`は緩く、失敗しても`0`を返す。厳密に変換したい場合は`Integer()`を使い、失敗は`ArgumentError`になる。`exception: false`を渡すと`nil`を返す。

n = int(s)

n = int("42")
f = float(n)
s = str(n)

int("abc")  # ValueError
int(3.9)    # 3（小数部は切り捨て）

try:
    n = int(text)
except ValueError:
    n = None

`int(x)`, `float(x)`, `str(x)`のように型名で変換する。失敗は`ValueError`で表され、`try`/`except`で処理する。整数は任意精度なので数値の範囲外による失敗は起きないが、失敗可能性は関数の型からは分からない。