nullable型: ? を付ける

ActiveWorkoutState の実コードを見てみよう:

const factory ActiveWorkoutState({
  String? routineId,
  required String routineName,
  required DateTime startedAt,
  required List<ActiveExerciseData> exercises,
  @Default(0) int currentExerciseIndex,
  @Default(false) bool isEditMode,
  String? editingSessionId,
})

String? の ? は「この値は null（存在しない）かもしれない」という宣言。

nullチェック3種

// 実コード: フリートレーニング開始
routineId: null,   // ルーティンなし
routineName: 'フリートレーニング',  // 名前はrequired（nullにできない）

// nullチェックの実例（saveSession内）
if (syncService != null && userId != null) {
  // 同期処理を実行
}

実コードのnullableフィールドを読み解く

abstract class ActiveWorkoutState with _$ActiveWorkoutState {
  const factory ActiveWorkoutState({
    String? routineId,          // nullable: フリートレーニング時はnull
    required String routineName, // non-null: 必ず名前がある
    required DateTime startedAt, // non-null: 必ず開始時刻がある
    required List<ActiveExerciseData> exercises,
    @Default(0) int currentExerciseIndex,
    @Default(false) bool isEditMode,
    String? editingSessionId,   // nullable: 新規作成時はnull
  })

ルール: 「ないかもしれない」ものだけ ? を付ける。

late — 「後で必ず入れる」宣言

テストコードの実例:

group('WorkoutRepository', () {
  late AppDatabase db;
  late WorkoutRepository repository;
  late String exerciseId;

  setUp(() async {
    db = AppDatabase.forTesting(NativeDatabase.memory());
    repository = WorkoutRepository(db);
    // ... exerciseId も setUp 内で代入
  });
});

nullで「不可能」を表現する

/// 推定1RM（Epley式）
double? get estimated1rm =>
    weight > 0 && reps > 0 ? weight * (1 + reps / 30) : null;

戻り値の型が double?。weight=0 のとき 1RM を計算する意味がないので、null で「計算不能」を表現している。

Repository でも同じパターン:

/// 指定種目の過去最高推定1RMを取得
Future<double?> getPersonalBest1RM(String exerciseId) async {
  // ... DB問い合わせ
  if (rows.isEmpty) return null;  // 記録がなければ null
  return rows.first.readTable(_db.workoutSets).estimated1rm;
}

List<T> — 順番付きの入れ物

const factory ActiveExerciseData({
  required String exerciseId,
  required String name,
  required List<SetData> sets,
  @Default([]) List<SetData> previousSets,
  double? personalBest1rm,
})

List<SetData> の <SetData> がジェネリクス。「この List の中身は SetData だけ」と宣言している。

メソッドチェーン: .where(), .map(), .toList()

/// 入力済みセット数
int get filledSetCount => sets.where((s) => s.hasData).length;

/// 1つでも入力されていれば完了扱い
bool get isCompleted => sets.any((s) => s.hasData);

もう一つの実例。前回記録を SetData に変換する処理:

final previousSets = lastSets
    .map((r) => SetData(weight: r.weight, reps: r.reps))
    .toList();

List.generate — N個の要素を自動生成

/// 新規セッション開始時のデフォルトセット数
const defaultSetCount = 3;

sets: List.generate(defaultSetCount, (_) => const SetData()),

(_) の _ は「引数を使わない」という意味。List.generate は各要素のインデックス(0,1,2)を渡すが、ここでは不要なので _ で無視している。

Map<K, V> — 名前で引ける辞書

シードデータで種目名からIDを引く Map:

final idByName = <String, String>{};
final seeds = [
  ('ベンチプレス', '胸', 'weight_reps'),
  ('インクラインダンベルプレス', '胸', 'weight_reps'),
  // ...
];
for (final (name, bodyPart, recordType) in seeds) {
  final id = uuid.v4();
  idByName[name] = id;  // 種目名 → ID の対応を記録
  // DB に insert ...
}

Set<T> — 重複なしの集合

カレンダーウィジェットの実コード:

// トレーニング実施日を Set<int> に変換して O(1) ルックアップ
final trainingDays = datesAsync.when(
  data: (dates) => dates.map((d) => d.day).toSet(),
  loading: () => <int>{},
  error: (_, _) => <int>{},
);

// 使う側
final hasTraining = trainingDays.contains(day);

関数シグネチャを読む — 3部読解

bool get hasData => weight > 0 || reps > 0;

関数を読むときは常にこの3つを確認する:

1. 何を受け取る? → 引数なし（getter なので自身の weight, reps を使う）
2. 何をする? → weight か reps が 0 より大きいか判定
3. 何を返す? → bool（true / false）

名前付き引数 vs 位置引数

// 名前付き引数（筋トレメモで使用）
const factory SetData({
  @Default(0) double weight,
  @Default(0) int reps,
  @Default(false) bool isPR,
})

// 呼び出し
SetData(weight: 60, reps: 10)

// もし位置引数だったら...
SetData(60, 10, false)  // 60が何で10が何か分かりにくい!

アロー関数 => vs ブロック {}

// アロー関数（1つの式だけ）
bool get hasData => weight > 0 || reps > 0;

// ブロック関数（複数の文）
double get totalVolume {
  var total = 0.0;
  for (final ex in exercises) {
    for (final s in ex.sets) {
      total += s.weight * s.reps;
    }
  }
  return total;
}

void — 何も返さないメソッド

void goToExercise(int index) {
  if (!_isValidExerciseIndex(index)) return;
  state = state!.copyWith(currentExerciseIndex: index);
}

void nextExercise() {
  if (state == null || state!.isLastExercise) return;
  goToExercise(state!.currentExerciseIndex + 1);
}

Future<void> — asyncメソッドのシグネチャ

Future<void> saveSession(
  ActiveWorkoutState recordState, {
  String? userId,
  SyncService? syncService,
}) async {
  // DB保存処理...
}

次のトピック 1-5 で async/await を詳しく学ぶ。

同期 vs 非同期

DB読み書き、ネットワーク通信は時間がかかる。同期的に待つとアプリが固まる（フリーズ）。

Future — 「いつか届く約束」

Future<List<WorkoutSet>> getLastSessionSets(String exerciseId) async {
  // DB問い合わせ（時間がかかる）
  final latestQuery = _db.select(...);
  final latestRows = await latestQuery.get();
  // ...
  return setsQuery.get();
}

async/await — 届くまで待つ

Future<void> startSession(RoutineWithExercises data) async {
  // 1. まず基本の state をセット（同期処理: 一瞬で完了）
  state = ActiveWorkoutState(...);

  // 2. 各種目の前回記録を取得（非同期: DB問い合わせ）
  for (final ex in state!.exercises) {
    final lastSets = await _repository.getLastSessionSets(ex.exerciseId);
    final best1rm = await _repository.getPersonalBest1RM(ex.exerciseId);
    // ...
  }
}

async = 「この関数の中で await を使います」という宣言。

await = 「Future の結果が届くまで待つ」。await を付けないと、まだ届いていない「約束」を使おうとしてエラーになる。

startSession の処理順序を追跡する

セッション開始の3段階を追跡する:

// 段階1: 基本 state をセット（空のセット3つで初期化）
state = ActiveWorkoutState(
  routineId: data.routine.id,
  routineName: data.routine.name,
  startedAt: targetDate ?? DateTime.now(),
  exercises: data.exercises.map((e) {
    return ActiveExerciseData(
      exerciseId: e.id, name: e.name,
      sets: List.generate(defaultSetCount, (_) => const SetData()),
    );
  }).toList(),
);

// 段階2: DB問い合わせ（await で1つずつ待つ）
for (final ex in state!.exercises) {
  final lastSets = await _repository.getLastSessionSets(ex.exerciseId);
  final best1rm = await _repository.getPersonalBest1RM(ex.exerciseId);
  // ...
}

// 段階3: state を更新（前回記録を反映）
state = state!.copyWith(exercises: updatedExercises);

処理の流れ:

1. 段階1: 空のセットで画面をすぐ表示（ユーザーを待たせない）
2. 段階2: DBから前回記録を取得（await で完了を待つ）
3. 段階3: 取得した前回記録で state を更新 → 画面に前回記録が表示される

Stream — 何度も届くデータ

/// 全ワークアウトをリアルタイムで監視（DB変更を自動検知）
Stream<List<Workout>> watchAllSessions() {
  return (_db.select(
    _db.workouts,
  )..orderBy([(t) => OrderingTerm.desc(t.date)])).watch();
}

比較: getAllSessions は Future（1回だけ）:

Future<List<Workout>> getAllSessions() {
  return (_db.select(_db.workouts)
    ..orderBy([(t) => OrderingTerm.desc(t.date)])).get();
}

初期化順序の罠

onCreate: (Migrator m) async {
  await m.createAll();
  final exerciseIdByName = await _seedExercises();
  await _seedRoutines(exerciseIdByName);
},

この順序を逆にすると?

// NG: ルーティンを先に作ろうとする
await _seedRoutines(exerciseIdByName);  // exerciseIdByNameが未定義!
final exerciseIdByName = await _seedExercises();

ルーティンは「ベンチプレスのID」を参照する。種目がまだDBにないのにルーティンを作ろうとすると失敗する。

コンパイルエラー vs 実行時エラー

まず、2種類のエラーの違いを確認しよう:

このトピックでは、enum と switch が「コンパイルエラーで守る」仕組みをどう作るかを学ぶ。

enum — 選択肢を型で定義する

筋トレメモの種目には「部位」がある。もし enum で定義するなら:

enum BodyPart {
  chest,    // 胸
  back,     // 背中
  legs,     // 脚
  shoulders,// 肩
  arms,     // 腕
  abs,      // 腹
  other,    // その他
}

しかし現在の筋トレメモでは String を使っている:

class Exercises extends Table {
  TextColumn get id => text()();
  TextColumn get name => text()();
  TextColumn get bodyPart => text()();   // String: "胸", "背中", ...
  TextColumn get recordType => text()();  // String: "weight_reps", ...
  DateTimeColumn get createdAt => dateTime()();
}

switch + enum — 書き忘れはコンパイルエラー

switch (bodyPart) {
  case BodyPart.chest:
    return '胸のトレーニング';
  case BodyPart.back:
    return '背中のトレーニング';
  case BodyPart.legs:
    return '脚のトレーニング';
  // shoulders, arms, abs, other を書き忘れると...
  // → コンパイルエラー! ビルドが通らない!
}

Dart の switch は enum の全 case を網羅しないとコンパイルエラーになる。これが exhaustive check（網羅性チェック）。

将来 enum に cardio（有酸素）を追加したら?

enum BodyPart {
  chest, back, legs, shoulders, arms, abs, other,
  cardio,  // 新規追加!
}
// → 全ての switch 文で「cardio の case がない」とコンパイルエラー!
// → 修正漏れがゼロになる

switch + String — typoは素通り

シードデータの実例:

final seeds = [
  ('ベンチプレス', '胸', 'weight_reps'),
  ('ラットプルダウン', '背中', 'weight_reps'),
  // ...
];

もし recordType で switch するなら:

switch (recordType) {  // recordType は String
  case 'weight_reps':
    return WeightRepsInput();
  case 'bodyweight_reps':
    return BodyweightInput();
  case 'time':
    return TimeInput();
  default:
    return Text('不明な記録タイプ');  // typoはここに落ちる
}

typo があっても:

('ベンチプレス', '胸', 'weght_reps'),  // typo: "weight" → "weght"
// コンパイルエラーにならない! 実行時に default に落ちて不正な表示!

Dart 3 のパターンマッチングNEW

シードデータでタプル（組）の分解が使われている:

final seeds = [
  ('ベンチプレス', '胸', 'weight_reps'),
  ('ラットプルダウン', '背中', 'weight_reps'),
  // ...
];
for (final (name, bodyPart, recordType) in seeds) {
  // name = 'ベンチプレス', bodyPart = '胸', recordType = 'weight_reps'
}

// パターンマッチングなし（従来の書き方）
for (final seed in seeds) {
  final name = seed.$1;       // 1番目の要素
  final bodyPart = seed.$2;   // 2番目の要素
  final recordType = seed.$3; // 3番目の要素
}

// パターンマッチングあり
for (final (name, bodyPart, recordType) in seeds) {
  // 直接使える!
}

ルーティンのシードでも同じパターン:

final routineSeeds = [
  ('胸の日', '#EF4444', ['ベンチプレス', 'インクラインダンベルプレス', 'ケーブルフライ']),
  // ...
];
for (var ri = 0; ri < routineSeeds.length; ri++) {
  final (name, color, exerciseNames) = routineSeeds[ri];
  // ...
}