Dart Listの型変換と複製：castとfromの挙動と選択

Dartは、静的型付け言語として、堅牢で安全なアプリケーション開発を支援します。その型システムの中核をなすのが、ジェネリクスをサポートしたコレクションであり、特にListは日常的なプログラミングにおいて最も頻繁に使用されるデータ構造の一つです。開発の現場では、APIからのレスポンスとして得られた動的なリストを特定の型に変換したり、状態管理のためにリストの不変性を保ちながら新しいリストを作成したりと、リストの型変換や複製が頻繁に求められます。

このような要求に応えるため、DartのListクラスは.cast()やList.from()といった強力なメソッドを提供しています。しかし、これらのメソッドは一見似ているように見えても、その内部的な動作、パフォーマンス特性、そしてメモリ管理への影響において根本的な違いを持っています。これらの違いを正確に理解せずに使用すると、予期せぬTypeErrorやパフォーマンスの低下、あるいは意図しない副作用を引き起こす可能性があります。本稿では、これらのメソッドの深層に迫り、それぞれのメカニズム、適切な使用シナリオ、そして現代的なDart開発におけるベストプラクティスを徹底的に解説します。

第一章: `List.from()` — 安全な複製と型変換の基礎

List.from()コンストラクタは、おそらくDartでリストを操作する上で最も基本的かつ汎用性の高いツールの一つです。その主な役割は、既存のIterable（List、Set、Queueなど）から要素を一つずつ読み取り、それらを含む全く新しいListインスタンスを生成することです。この「新しいインスタンスを生成する」という点が、List.from()を理解する上での最も重要な鍵となります。

1.1 基本的な使用法：独立したリストの作成

List.from()の最もシンプルな使い方は、既存のリストの完全なコピーを作成することです。これにより、元のリストとは独立した、ミュータブル（変更可能）な新しいリストが手に入ります。

void main() {
  List<int> originalList = [1, 2, 3];
  
  // List.from() を使って新しいリストを作成
  List<int> copiedList = List<int>.from(originalList);

  print('originalList: $originalList'); // 出力: originalList: [1, 2, 3]
  print('copiedList:   $copiedList');   // 出力: copiedList:   [1, 2, 3]

  // コピーしたリストを変更する
  copiedList.add(4);

  print('After modification:');
  print('originalList: $originalList'); // 出力: originalList: [1, 2, 3] (影響を受けない)
  print('copiedList:   $copiedList');   // 出力: copiedList:   [1, 2, 3, 4] (変更が反映される)

  // 2つのリストが異なるインスタンスであることを確認
  print(identical(originalList, copiedList)); // 出力: false
}

上記のコードが示すように、copiedListへの変更はoriginalListに一切影響を与えません。これは、List.from()がメモリ上に新しい領域を確保し、元のリストの各要素をそこにコピーしたためです。状態管理ライブラリ（Provider, BLoC, Riverpodなど）で不変性（Immutability）を保つ必要がある場合や、元のデータを汚染せずにリストを加工したい場合に、この特性は極めて重要です。

1.2 シャローコピー（Shallow Copy）の挙動と注意点

List.from()は「シャローコピー」を行うことを理解しておく必要があります。これは、リストがプリミティブ型（int, double, Stringなど）を保持している場合は問題になりませんが、リストがオブジェクトの参照を保持している場合には注意が必要です。

シャローコピーでは、リスト自体は新しく作成されますが、そのリストが保持する要素（オブジェクト）は元のリストが参照しているものと同じインスタンスを指します。つまり、オブジェクトそのものは複製されません。

class User {
  String name;
  User(this.name);

  @override
  String toString() => 'User(name: $name)';
}

void main() {
  var userA = User('Alice');
  var userB = User('Bob');
  
  List<User> originalUsers = [userA, userB];
  List<User> copiedUsers = List.from(originalUsers);

  print('Before modification:');
  print('originalUsers: $originalUsers'); // [User(name: Alice), User(name: Bob)]
  print('copiedUsers:   $copiedUsers');   // [User(name: Alice), User(name: Bob)]
  
  // コピーしたリスト内のオブジェクトのプロパティを変更
  copiedUsers[0].name = 'Alicia';
  
  print('\nAfter modification:');
  print('originalUsers: $originalUsers'); // [User(name: Alicia), User(name: Bob)] (影響を受ける！)
  print('copiedUsers:   $copiedUsers');   // [User(name: Alicia), User(name: Bob)]

  // リストのインスタンスは異なるが...
  print('\nList instances are different: ${!identical(originalUsers, copiedUsers)}'); // true
  // ...リスト内のオブジェクトのインスタンスは同じ
  print('User instances are identical: ${identical(originalUsers[0], copiedUsers[0])}'); // true
}

この例では、copiedUsersの最初の要素であるUserオブジェクトのnameプロパティを変更すると、originalUsersの対応する要素も変更されてしまっています。これは両方のリストが同じUserインスタンスを共有しているためです。もしオブジェクトも含めて完全に独立したコピー（ディープコピー）が必要な場合は、List.from()と組み合わせて、各オブジェクトを個別にクローンするロジックを実装する必要があります（例：.map((user) => user.clone()).toList()）。

1.3 型変換の機能

List.from()は、単なる複製だけでなく、型変換の機能も内包しています。ソースとなるIterableの要素が、生成したいリストの型に代入可能（assignable）である場合、暗黙的な型変換が行われます。

void main() {
  List<int> intList = [1, 2, 3];

  // List<int> から List<num> へ変換
  // int は num のサブタイプなので、この変換は安全
  List<num> numList = List<num>.from(intList);
  print('numList: $numList'); // 出力: numList: [1, 2, 3]
  print(numList.runtimeType); // 出力: List<num>

  List<dynamic> dynamicList = [1, 2.5, 'hello'];
  
  // List<dynamic> から List<Object> へ変換
  // 全ての型は Object のサブタイプなので、これも安全
  List<Object> objectList = List<Object>.from(dynamicList);
  print('objectList: $objectList'); // 出力: objectList: [1, 2.5, hello]
}

この機能は、サブタイプからスーパータイプへのアップキャスト（upcasting）において安全に機能します。しかし、互換性のない型へ変換しようとすると、実行時エラーが発生します。

void main() {
  try {
    List<Object> objectList = [1, 'two', 3];
    // Object を int にダウンキャストしようとするが、'two' が原因で失敗する
    List<int> intList = List<int>.from(objectList);
    print(intList);
  } catch (e) {
    // 実行時エラー: type 'String' is not a subtype of type 'int' in type cast
    print(e); 
  }
}

このように、List.from()は新しいリストを生成する際に型チェックも行い、安全でない変換を未然に防ぎます。この挙動は、後述する.cast()の遅延評価とは対照的です。

1.4 growableパラメータ

List.from()コンストラクタは、オプションでgrowableという真偽値パラメータを取ります。デフォルトはtrueで、これにより生成されたリストは.add()や.remove()といったメソッドで長さを変更できます。これをfalseに設定すると、固定長のリストが生成されます。

void main() {
  List<int> source = [1, 2, 3];
  
  // growable: false で固定長リストを作成
  var fixedList = List.from(source, growable: false);
  print(fixedList.runtimeType); // _ImmutableList<int> などの内部的な固定長リスト型になる
  
  try {
    fixedList.add(4); // 固定長リストへの追加はエラー
  } catch (e) {
    // UnsupportedError: Cannot add to a fixed-length list
    print(e);
  }
}

リストの長さが今後変わらないことが分かっている場合、growable: falseを指定することで、パフォーマンスがわずかに向上し、意図しない変更を防ぐという点でコードの堅牢性も高まります。

第二章: `.cast()` — 型の「ビュー」を生成する軽量なラッパー

.cast()メソッドは、List.from()とは全く異なるアプローチで型変換を実現します。これは新しいリストを物理的にメモリ上に作成するのではなく、元のリストをラップし、指定された型であるかのように見せかけるビュー（View）を返します。このビューはCastListという特殊なクラスのインスタンスです。

2.1 遅延評価（Lazy Evaluation）のメカニズム

.cast()の最大の特徴は、その遅延評価にあります。.cast()を呼び出した瞬間には、リスト内の全要素に対する型チェックは一切行われません。このメソッドの呼び出しは非常に高速（O(1)）で、メモリ消費もほとんどありません。実際の型チェックとキャストは、ビューを通じて個々の要素にアクセスしようとしたその瞬間に初めて実行されます。

void main() {
  List<num> numList = [1, 2.5, 3];

  // .cast<int>() を呼び出す。この時点ではエラーは発生しない。
  List<int> intView = numList.cast<int>();
  print('Cast operation completed without error.');
  
  try {
    // 要素にアクセスしようとすると、型チェックが実行される
    for (var i in intView) {
      print(i); // 1 を出力した後、2.5 を int にキャストしようとしてエラーが発生
    }
  } catch (e) {
    // TypeError: type 'double' is not a subtype of type 'int' in type cast
    print(e);
  }
}

この例では、numListにはintにキャストできないdouble（2.5）が含まれていますが、.cast<int>()の行ではエラーになりません。エラーが発生するのは、forループ内で2.5にアクセスし、intとして扱おうとした時点です。この遅延評価の性質は、巨大なリストを扱う際に、実際に使用する要素だけをチェックすれば良いため、パフォーマンス上の利点となることがあります。

2.2 元のリストとの連動

.cast()が生成するのはビューであるため、そのビューは元のリストと強く結合しています。元のリストに加えられた変更は、即座にキャストされたビューにも反映されます。逆もまた然りです。

void main() {
  List<num> originalList = [1, 2, 3];
  
  // numのリストをdoubleのビューとして扱う
  List<double> castedView = originalList.cast<double>();
  
  print('Before modification:');
  print('originalList: $originalList'); // [1, 2, 3]
  print('castedView:   $castedView');   // [1.0, 2.0, 3.0]
  
  // 元のリストを変更する
  originalList.add(4);
  originalList[0] = 10;
  
  print('\nAfter modifying originalList:');
  print('originalList: $originalList'); // [10, 2, 3, 4]
  print('castedView:   $castedView');   // [10.0, 2.0, 3.0, 4.0] (変更が反映される)

  // キャストされたビューを通して要素を追加する
  // 追加する要素は、ビューの型(double)と元のリストの型(num)の両方に適合する必要がある
  castedView.add(5.0);

  print('\nAfter modifying castedView:');
  print('originalList: $originalList'); // [10, 2, 3, 4, 5.0] (こちらにも反映される)
  print('castedView:   $castedView');   // [10.0, 2.0, 3.0, 4.0, 5.0]
}

この挙動は、元のデータソースを直接操作したいが、特定のAPIには特定の型として渡す必要がある、といった限定的なシナリオで役立つことがあります。しかし、一般的には予期せぬ副作用の原因となり得るため、この連動性を意識せずに使用するのは危険です。

2.3 `.cast()`の適切な使用シナリオ

.cast()が真価を発揮するのは、型システム上は異なるが、実行時にはその型であることが保証されているリストを、メモリコピーなしで効率的に扱いたい場合です。

典型的な例は、JSONデシリアライズの結果として得られるList<dynamic>の扱いです。

import 'dart:convert';

void main() {
  String jsonString = '["apple", "banana", "cherry"]';
  
  // jsonDecodeは List<dynamic> を返す
  List<dynamic> dynamicList = json.decode(jsonString);
  
  // このJSONの構造から、中身は全てStringであることが分かっている
  // 新しいリストを作成せずに、型付けされたリストとして扱うことができる
  List<String> stringList = dynamicList.cast<String>();
  
  // これで stringList は List<String> として扱える
  print(stringList.first.toUpperCase()); // APPLE
}

このシナリオでは、dynamicListの要素がすべてStringであるという事前知識（契約）に基づいて.cast()を使用しています。もし万が一、JSONデータに"apple", 123, "cherry"のような数値が含まれていた場合、123にアクセスした瞬間に実行時エラーが発生します。したがって、.cast()は「信じるが、検証は遅延する」というアプローチであり、データの信頼性が高い場面での使用が推奨されます。

第三章: 非推奨となった `List.castFrom()`

かつてDartにはList.castFrom()という静的メソッドが存在しました。これは、List.from()のように新しいリストを生成しつつ、.cast()のように要素の型変換を行う、両者の中間のような挙動を持っていました。

// 古いコードやドキュメントで見られる可能性のある例（現在は非推奨）
// List<int> intList = [1, 2, 3];
// List<double> doubleList = List<double>.castFrom(intList); 

このメソッドは、Dart 2.12で非推奨（deprecated）となり、その後のバージョンで削除されました。非推奨となった主な理由は、その機能が他のメソッドの組み合わせでより明確に、そして柔軟に実現できるためです。

List.castFrom(source)と等価な現代的な書き方は、主に以下の2つです。

1. List.from(source.cast<T>()): .cast()でビューを作成し、そのビューをList.from()で新しいリストに実体化させる方法。
2. source.map((e) => e as T).toList(): .map()を使って各要素を明示的にキャストし、最後に.toList()で新しいリストに変換する方法。

特に後者の.map().toList()は、単なる型キャストだけでなく、e.toDouble()のような具体的な変換処理も記述できるため、より柔軟性が高く、現在ではリストの変換における標準的なイディオムとなっています。

第四章: 徹底比較と実践的な選択基準

これまで見てきたように、List.from()と.cast()は似た目的（型変換やリスト操作）に使えますが、そのアプローチは全く異なります。どちらを選択するかは、開発者が何を達成したいのかに依存します。

4.1 比較表

特性	List.from()	.cast()
新しいリストの生成	はい（メモリ上に新しいリストを作成）	いいえ（元のリストをラップするビューを生成）
元のリストとの関係	独立（変更は互いに影響しない）	連動（変更は双方向に反映される）
パフォーマンス（生成時）	O(n) - 全要素を走査してコピー	O(1) - ラッパーオブジェクトの生成のみ
型チェックのタイミング	即時評価（Eager）- 生成時に全要素をチェック	遅延評価（Lazy）- 要素アクセス時にチェック
主な使用シナリオ	リストの安全な複製、不変性の確保、他のIterableからのリスト化	型が保証されたリストの効率的な型付け、メモリコピーの回避
エラー発生箇所	List.from()の呼び出し行	キャストされたリストの要素にアクセスする行

4.2 ユースケースに基づく選択フロー

どのメソッドを使うべきか迷ったときは、以下の質問を自問自答することで、最適な選択肢にたどり着くことができます。

1. 元のリストを変更から保護したいですか？ または、完全に独立した新しいリストが必要ですか？
   • はい → List.from()、または.map(...).toList()、あるいはスプレッド演算子[...sourceList]を使用します。これらはすべて新しいリストを生成し、不変性を保証するのに役立ちます。これが最も一般的で安全な選択です。

     // 安全なコピー
     List<int> safeCopy = List.from(originalList);
     
     // 値を変換しつつのコピー
     List<String> stringCopy = originalList.map((i) => i.toString()).toList();
           

   • いいえ → 次の質問へ
2. リストの要素の「値」を変換（例: intをdoubleに、Userオブジェクトをそのidに）する必要がありますか？
   • はい → .map().toList()が最適です。これは各要素に対して変換関数を適用でき、最も柔軟性が高い方法です。

     
     List<int> ids = [1, 2, 3];
     List<double> doubles = ids.map((id) => id.toDouble()).toList();
           

   • いいえ → 次の質問へ
3. 単にコンパイラに「このリストの要素は実際にはこのサブタイプです」と伝えたいだけで、新しいリストのメモリ確保は避けたいですか？ そして、その型が正しいことに強い確信がありますか？
   • はい → .cast()が適切な選択肢です。パフォーマンスが最優先され、かつデータの型安全性が外部の契約によって保証されている場合に有効です。

     
     // APIからのレスポンスなど、中身がStringだと確信している場合
     List<dynamic> apiResponse = ['data1', 'data2'];
     List<String> data = apiResponse.cast<String>();
           

   • いいえ（型に確信がない） → 安全策を取り、List.from()や.map()を使ってください。あるいは、whereType()メソッドで安全に特定の型の要素だけを抽出することもできます。

     
     List<dynamic> mixedList = [1, 'apple', 2, 'banana'];
     // String型の要素だけを安全に抽出して新しいリストを作成
     List<String> fruits = mixedList.whereType<String>().toList(); // ['apple', 'banana']
           

結論

DartにおけるList.from()と.cast()は、リストの型変換と操作のための重要なツールですが、その哲学は大きく異なります。List.from()は「生成と検証」を重視し、新しい独立したリストを作成することで安全性と不変性を提供します。これは多くのアプリケーションにおいてデフォルトで選択すべき、堅牢なアプローチです。一方、.cast()は「信頼と効率」を重視し、メモリコピーを犠牲にして元のリストの軽量な型付きビューを提供します。これはパフォーマンスが重要な場面や、型の正しさが保証されている特殊な状況で強力な武器となります。

現代のDartプログラミングでは、多くの場合、List.from()や、より表現力豊かな.map().toList()、スプレッド演算子[...]が、予測可能で副作用のないコードを書くための推奨される方法です。.cast()はその特性を深く理解し、元のリストとの連動性や遅延評価される実行時エラーのリスクを許容できる場合にのみ、慎重に使用すべきでしょう。これらのツールの違いを正確に把握し、コンテキストに応じて適切に使い分けることが、高品質でメンテナンス性の高いDartアプリケーションを構築するための鍵となります。