[{"data":1,"prerenderedAt":2983},["ShallowReactive",2],{"page-\u002Fdart\u002F04-control-flow":3},{"id":4,"title":5,"body":6,"description":2976,"extension":2977,"meta":2978,"navigation":57,"path":2979,"seo":2980,"stem":2981,"__hash__":2982},"content\u002Fdart\u002F04-control-flow.md","Dart — Control Flow, Exhaustiveness & Pattern Matching",{"type":7,"value":8,"toc":2961},"minimark",[9,13,18,422,431,621,625,1558,1562,1830,1837,2237,2244,2475,2479,2548,2552,2720,2724,2732,2812,2815,2957],[10,11,5],"h1",{"id":12},"dart-control-flow-exhaustiveness-pattern-matching",[14,15,17],"h2",{"id":16},"exhaustive-switches-the-compiler-safety-net","Exhaustive Switches — The Compiler Safety Net",[19,20,22],"code-wrapper",{"language":21},"dart",[23,24,28],"pre",{"className":25,"code":26,"language":21,"meta":27,"style":27},"language-dart shiki shiki-themes github-light github-dark","\u002F\u002F Dart 3 exhaustive switches: if you handle all subtypes of a sealed type,\n\u002F\u002F the compiler ENFORCES completeness — no `default` needed, and adding a\n\u002F\u002F new subtype causes a compile error at every non-exhaustive switch.\n\nsealed class Result\u003CT> {\n  const Result();\n}\n\nclass Success\u003CT> extends Result\u003CT> {\n  final T value;\n  const Success(this.value);\n}\n\nclass Failure\u003CT> extends Result\u003CT> {\n  final String error;\n  const Failure(this.error);\n}\n\nclass Loading\u003CT> extends Result\u003CT> {\n  const Loading();\n}\n\n\u002F\u002F Exhaustive — all three subtypes handled. No `default` needed.\nString describe\u003CT>(Result\u003CT> r) => switch (r) {\n  Success(:final value) => 'OK: $value',  \u002F\u002F destructuring pattern: extracts .value\n  Failure(:final error) => 'ERR: $error',\n  Loading() => 'Loading...',\n};\n\n\u002F\u002F If you later add `class Idle\u003CT> extends Result\u003CT> {}`, every switch like the\n\u002F\u002F above becomes a COMPILE ERROR: \"Idle is not handled.\" This is the safety net —\n\u002F\u002F you can't forget a case.\n","",[29,30,31,40,46,52,59,83,94,100,105,132,144,160,165,170,194,205,219,224,229,253,262,267,272,278,314,349,377,393,399,404,410,416],"code",{"__ignoreMap":27},[32,33,36],"span",{"class":34,"line":35},"line",1,[32,37,39],{"class":38},"sdCPZ","\u002F\u002F Dart 3 exhaustive switches: if you handle all subtypes of a sealed type,\n",[32,41,43],{"class":34,"line":42},2,[32,44,45],{"class":38},"\u002F\u002F the compiler ENFORCES completeness — no `default` needed, and adding a\n",[32,47,49],{"class":34,"line":48},3,[32,50,51],{"class":38},"\u002F\u002F new subtype causes a compile error at every non-exhaustive switch.\n",[32,53,55],{"class":34,"line":54},4,[32,56,58],{"emptyLinePlaceholder":57},true,"\n",[32,60,62,66,69,73,77,80],{"class":34,"line":61},5,[32,63,65],{"class":64},"svdQ7","sealed",[32,67,68],{"class":64}," class",[32,70,72],{"class":71},"snvgF"," Result",[32,74,76],{"class":75},"ssxIu","\u003C",[32,78,79],{"class":71},"T",[32,81,82],{"class":75},"> {\n",[32,84,86,89,91],{"class":34,"line":85},6,[32,87,88],{"class":64},"  const",[32,90,72],{"class":71},[32,92,93],{"class":75},"();\n",[32,95,97],{"class":34,"line":96},7,[32,98,99],{"class":75},"}\n",[32,101,103],{"class":34,"line":102},8,[32,104,58],{"emptyLinePlaceholder":57},[32,106,108,111,114,116,118,121,124,126,128,130],{"class":34,"line":107},9,[32,109,110],{"class":64},"class",[32,112,113],{"class":71}," Success",[32,115,76],{"class":75},[32,117,79],{"class":71},[32,119,120],{"class":75},"> ",[32,122,123],{"class":64},"extends",[32,125,72],{"class":71},[32,127,76],{"class":75},[32,129,79],{"class":71},[32,131,82],{"class":75},[32,133,135,138,141],{"class":34,"line":134},10,[32,136,137],{"class":64},"  final",[32,139,140],{"class":71}," T",[32,142,143],{"class":75}," value;\n",[32,145,147,149,151,154,157],{"class":34,"line":146},11,[32,148,88],{"class":64},[32,150,113],{"class":71},[32,152,153],{"class":75},"(",[32,155,156],{"class":71},"this",[32,158,159],{"class":75},".value);\n",[32,161,163],{"class":34,"line":162},12,[32,164,99],{"class":75},[32,166,168],{"class":34,"line":167},13,[32,169,58],{"emptyLinePlaceholder":57},[32,171,173,175,178,180,182,184,186,188,190,192],{"class":34,"line":172},14,[32,174,110],{"class":64},[32,176,177],{"class":71}," Failure",[32,179,76],{"class":75},[32,181,79],{"class":71},[32,183,120],{"class":75},[32,185,123],{"class":64},[32,187,72],{"class":71},[32,189,76],{"class":75},[32,191,79],{"class":71},[32,193,82],{"class":75},[32,195,197,199,202],{"class":34,"line":196},15,[32,198,137],{"class":64},[32,200,201],{"class":71}," String",[32,203,204],{"class":75}," error;\n",[32,206,208,210,212,214,216],{"class":34,"line":207},16,[32,209,88],{"class":64},[32,211,177],{"class":71},[32,213,153],{"class":75},[32,215,156],{"class":71},[32,217,218],{"class":75},".error);\n",[32,220,222],{"class":34,"line":221},17,[32,223,99],{"class":75},[32,225,227],{"class":34,"line":226},18,[32,228,58],{"emptyLinePlaceholder":57},[32,230,232,234,237,239,241,243,245,247,249,251],{"class":34,"line":231},19,[32,233,110],{"class":64},[32,235,236],{"class":71}," Loading",[32,238,76],{"class":75},[32,240,79],{"class":71},[32,242,120],{"class":75},[32,244,123],{"class":64},[32,246,72],{"class":71},[32,248,76],{"class":75},[32,250,79],{"class":71},[32,252,82],{"class":75},[32,254,256,258,260],{"class":34,"line":255},20,[32,257,88],{"class":64},[32,259,236],{"class":71},[32,261,93],{"class":75},[32,263,265],{"class":34,"line":264},21,[32,266,99],{"class":75},[32,268,270],{"class":34,"line":269},22,[32,271,58],{"emptyLinePlaceholder":57},[32,273,275],{"class":34,"line":274},23,[32,276,277],{"class":38},"\u002F\u002F Exhaustive — all three subtypes handled. No `default` needed.\n",[32,279,281,284,288,290,292,295,298,300,302,305,308,311],{"class":34,"line":280},24,[32,282,283],{"class":71},"String",[32,285,287],{"class":286},"sIsaT"," describe",[32,289,76],{"class":75},[32,291,79],{"class":71},[32,293,294],{"class":75},">(",[32,296,297],{"class":71},"Result",[32,299,76],{"class":75},[32,301,79],{"class":71},[32,303,304],{"class":75},"> r) ",[32,306,307],{"class":64},"=>",[32,309,310],{"class":64}," switch",[32,312,313],{"class":75}," (r) {\n",[32,315,317,320,322,325,328,330,334,337,340,343,346],{"class":34,"line":316},25,[32,318,319],{"class":71},"  Success",[32,321,153],{"class":75},[32,323,324],{"class":64},":final",[32,326,327],{"class":75}," value) ",[32,329,307],{"class":64},[32,331,333],{"class":332},"sJ6F3"," 'OK: ",[32,335,336],{"class":332},"$",[32,338,339],{"class":71},"value",[32,341,342],{"class":332},"'",[32,344,345],{"class":75},",  ",[32,347,348],{"class":38},"\u002F\u002F destructuring pattern: extracts .value\n",[32,350,352,355,357,359,362,364,367,369,372,374],{"class":34,"line":351},26,[32,353,354],{"class":71},"  Failure",[32,356,153],{"class":75},[32,358,324],{"class":64},[32,360,361],{"class":75}," error) ",[32,363,307],{"class":64},[32,365,366],{"class":332}," 'ERR: ",[32,368,336],{"class":332},[32,370,371],{"class":71},"error",[32,373,342],{"class":332},[32,375,376],{"class":75},",\n",[32,378,380,383,386,388,391],{"class":34,"line":379},27,[32,381,382],{"class":71},"  Loading",[32,384,385],{"class":75},"() ",[32,387,307],{"class":64},[32,389,390],{"class":332}," 'Loading...'",[32,392,376],{"class":75},[32,394,396],{"class":34,"line":395},28,[32,397,398],{"class":75},"};\n",[32,400,402],{"class":34,"line":401},29,[32,403,58],{"emptyLinePlaceholder":57},[32,405,407],{"class":34,"line":406},30,[32,408,409],{"class":38},"\u002F\u002F If you later add `class Idle\u003CT> extends Result\u003CT> {}`, every switch like the\n",[32,411,413],{"class":34,"line":412},31,[32,414,415],{"class":38},"\u002F\u002F above becomes a COMPILE ERROR: \"Idle is not handled.\" This is the safety net —\n",[32,417,419],{"class":34,"line":418},32,[32,420,421],{"class":38},"\u002F\u002F you can't forget a case.\n",[423,424,426,427,430],"h3",{"id":425},"the-default-trap","The ",[29,428,429],{},"default"," Trap",[19,432,433],{"language":21},[23,434,436],{"className":25,"code":435,"language":21,"meta":27,"style":27},"enum Status { pending, active, completed }\n\n\u002F\u002F ❌ Anti-pattern: using `default` in an enum switch.\nString labelBad(Status s) => switch (s) {\n  Status.pending => 'Pending',\n  Status.active => 'Active',\n  _ => 'Completed',  \u002F\u002F wildcard catches everything else — including FUTURE values\n};\n\n\u002F\u002F If `Status.cancelled` is added later, `_` silently catches it and returns\n\u002F\u002F 'Completed' — a silent semantic bug. The compiler can't warn you.\n\n\u002F\u002F ✓ Correct: handle every case explicitly, no wildcard.\nString labelGood(Status s) => switch (s) {\n  Status.pending => 'Pending',\n  Status.active => 'Active',\n  Status.completed => 'Completed',\n  \u002F\u002F Adding Status.cancelled here → compile error: non-exhaustive switch.\n  \u002F\u002F The compiler FORCES you to handle the new case.\n};\n",[29,437,438,449,453,458,480,495,509,524,528,532,537,542,546,551,570,582,594,607,612,617],{"__ignoreMap":27},[32,439,440,443,446],{"class":34,"line":35},[32,441,442],{"class":64},"enum",[32,444,445],{"class":71}," Status",[32,447,448],{"class":75}," { pending, active, completed }\n",[32,450,451],{"class":34,"line":42},[32,452,58],{"emptyLinePlaceholder":57},[32,454,455],{"class":34,"line":48},[32,456,457],{"class":38},"\u002F\u002F ❌ Anti-pattern: using `default` in an enum switch.\n",[32,459,460,462,465,467,470,473,475,477],{"class":34,"line":54},[32,461,283],{"class":71},[32,463,464],{"class":286}," labelBad",[32,466,153],{"class":75},[32,468,469],{"class":71},"Status",[32,471,472],{"class":75}," s) ",[32,474,307],{"class":64},[32,476,310],{"class":64},[32,478,479],{"class":75}," (s) {\n",[32,481,482,485,488,490,493],{"class":34,"line":61},[32,483,484],{"class":71},"  Status",[32,486,487],{"class":75},".pending ",[32,489,307],{"class":64},[32,491,492],{"class":332}," 'Pending'",[32,494,376],{"class":75},[32,496,497,499,502,504,507],{"class":34,"line":85},[32,498,484],{"class":71},[32,500,501],{"class":75},".active ",[32,503,307],{"class":64},[32,505,506],{"class":332}," 'Active'",[32,508,376],{"class":75},[32,510,511,514,516,519,521],{"class":34,"line":96},[32,512,513],{"class":75},"  _ ",[32,515,307],{"class":64},[32,517,518],{"class":332}," 'Completed'",[32,520,345],{"class":75},[32,522,523],{"class":38},"\u002F\u002F wildcard catches everything else — including FUTURE values\n",[32,525,526],{"class":34,"line":102},[32,527,398],{"class":75},[32,529,530],{"class":34,"line":107},[32,531,58],{"emptyLinePlaceholder":57},[32,533,534],{"class":34,"line":134},[32,535,536],{"class":38},"\u002F\u002F If `Status.cancelled` is added later, `_` silently catches it and returns\n",[32,538,539],{"class":34,"line":146},[32,540,541],{"class":38},"\u002F\u002F 'Completed' — a silent semantic bug. The compiler can't warn you.\n",[32,543,544],{"class":34,"line":162},[32,545,58],{"emptyLinePlaceholder":57},[32,547,548],{"class":34,"line":167},[32,549,550],{"class":38},"\u002F\u002F ✓ Correct: handle every case explicitly, no wildcard.\n",[32,552,553,555,558,560,562,564,566,568],{"class":34,"line":172},[32,554,283],{"class":71},[32,556,557],{"class":286}," labelGood",[32,559,153],{"class":75},[32,561,469],{"class":71},[32,563,472],{"class":75},[32,565,307],{"class":64},[32,567,310],{"class":64},[32,569,479],{"class":75},[32,571,572,574,576,578,580],{"class":34,"line":196},[32,573,484],{"class":71},[32,575,487],{"class":75},[32,577,307],{"class":64},[32,579,492],{"class":332},[32,581,376],{"class":75},[32,583,584,586,588,590,592],{"class":34,"line":207},[32,585,484],{"class":71},[32,587,501],{"class":75},[32,589,307],{"class":64},[32,591,506],{"class":332},[32,593,376],{"class":75},[32,595,596,598,601,603,605],{"class":34,"line":221},[32,597,484],{"class":71},[32,599,600],{"class":75},".completed ",[32,602,307],{"class":64},[32,604,518],{"class":332},[32,606,376],{"class":75},[32,608,609],{"class":34,"line":226},[32,610,611],{"class":38},"  \u002F\u002F Adding Status.cancelled here → compile error: non-exhaustive switch.\n",[32,613,614],{"class":34,"line":231},[32,615,616],{"class":38},"  \u002F\u002F The compiler FORCES you to handle the new case.\n",[32,618,619],{"class":34,"line":255},[32,620,398],{"class":75},[14,622,624],{"id":623},"pattern-matching-destructuring-guards","Pattern Matching — Destructuring & Guards",[19,626,627],{"language":21},[23,628,630],{"className":25,"code":629,"language":21,"meta":27,"style":27},"\u002F\u002F Dart 3 patterns: destructuring, type matching, guard clauses (`when`).\n\n\u002F\u002F Record destructuring in switch:\n(int x, int y) point = (3, 4);\nString quadrant = switch (point) {\n  (0, 0) => 'origin',\n  (int x, 0) when x > 0 => 'positive x-axis',\n  (int x, 0) => 'negative x-axis',\n  (0, int y) => 'y-axis',\n  (int x, int y) when x > 0 && y > 0 => 'Q1',\n  (int x, int y) when x \u003C 0 && y > 0 => 'Q2',\n  (int x, int y) when x \u003C 0 && y \u003C 0 => 'Q3',\n  _ => 'Q4',\n};\n\n\u002F\u002F Type + destructuring patterns:\nsealed class Shape {}\nclass Circle extends Shape { final double r; Circle(this.r); }\nclass Rectangle extends Shape { final double w, h; Rectangle(this.w, this.h); }\nclass Triangle extends Shape { final double a, b, c; Triangle(this.a, this.b, this.c); }\n\ndouble area(Shape s) => switch (s) {\n  Circle(:final r) => 3.14159 * r * r,\n  Rectangle(:final w, :final h) => w * h,\n  Triangle(:final a, :final b, :final c) {\n    final semi = (a + b + c) \u002F 2;\n    return (semi * (semi - a) * (semi - b) * (semi - c)).abs();\n  }\n};\n\n\u002F\u002F `if` with patterns (Dart 3):\nvoid handleShape(Shape s) {\n  if (s case Circle(:final r) when r > 100) {\n    print('Large circle: $r');\n  } else if (s case Rectangle(:final w, :final h) when w == h) {\n    print('Square: ${w}x${h}');\n  }\n}\n\n\u002F\u002F Map pattern (destructuring by key):\nswitch (json) {\n  case {'type': 'point', 'x': int x, 'y': int y}:\n    print('Point at ($x, $y)');\n  case {'type': 'circle', 'radius': double r}:\n    print('Circle radius $r');\n  case {'type': String type}:\n    print('Unknown type: $type');\n}\n",[29,631,632,637,641,646,679,693,715,747,766,786,823,858,893,904,908,912,917,929,963,998,1038,1042,1063,1092,1119,1141,1174,1215,1220,1224,1228,1233,1248,1280,1300,1338,1371,1376,1381,1386,1392,1401,1444,1470,1498,1516,1534,1553],{"__ignoreMap":27},[32,633,634],{"class":34,"line":35},[32,635,636],{"class":38},"\u002F\u002F Dart 3 patterns: destructuring, type matching, guard clauses (`when`).\n",[32,638,639],{"class":34,"line":42},[32,640,58],{"emptyLinePlaceholder":57},[32,642,643],{"class":34,"line":48},[32,644,645],{"class":38},"\u002F\u002F Record destructuring in switch:\n",[32,647,648,650,653,656,658,661,664,667,670,673,676],{"class":34,"line":54},[32,649,153],{"class":75},[32,651,652],{"class":71},"int",[32,654,655],{"class":75}," x, ",[32,657,652],{"class":71},[32,659,660],{"class":75}," y) point ",[32,662,663],{"class":64},"=",[32,665,666],{"class":75}," (",[32,668,669],{"class":71},"3",[32,671,672],{"class":75},", ",[32,674,675],{"class":71},"4",[32,677,678],{"class":75},");\n",[32,680,681,683,686,688,690],{"class":34,"line":61},[32,682,283],{"class":71},[32,684,685],{"class":75}," quadrant ",[32,687,663],{"class":64},[32,689,310],{"class":64},[32,691,692],{"class":75}," (point) {\n",[32,694,695,698,701,703,705,708,710,713],{"class":34,"line":85},[32,696,697],{"class":75},"  (",[32,699,700],{"class":71},"0",[32,702,672],{"class":75},[32,704,700],{"class":71},[32,706,707],{"class":75},") ",[32,709,307],{"class":64},[32,711,712],{"class":332}," 'origin'",[32,714,376],{"class":75},[32,716,717,719,721,723,725,727,730,733,736,739,742,745],{"class":34,"line":96},[32,718,697],{"class":75},[32,720,652],{"class":71},[32,722,655],{"class":75},[32,724,700],{"class":71},[32,726,707],{"class":75},[32,728,729],{"class":64},"when",[32,731,732],{"class":75}," x ",[32,734,735],{"class":64},">",[32,737,738],{"class":71}," 0",[32,740,741],{"class":64}," =>",[32,743,744],{"class":332}," 'positive x-axis'",[32,746,376],{"class":75},[32,748,749,751,753,755,757,759,761,764],{"class":34,"line":102},[32,750,697],{"class":75},[32,752,652],{"class":71},[32,754,655],{"class":75},[32,756,700],{"class":71},[32,758,707],{"class":75},[32,760,307],{"class":64},[32,762,763],{"class":332}," 'negative x-axis'",[32,765,376],{"class":75},[32,767,768,770,772,774,776,779,781,784],{"class":34,"line":107},[32,769,697],{"class":75},[32,771,700],{"class":71},[32,773,672],{"class":75},[32,775,652],{"class":71},[32,777,778],{"class":75}," y) ",[32,780,307],{"class":64},[32,782,783],{"class":332}," 'y-axis'",[32,785,376],{"class":75},[32,787,788,790,792,794,796,798,800,802,804,806,809,812,814,816,818,821],{"class":34,"line":134},[32,789,697],{"class":75},[32,791,652],{"class":71},[32,793,655],{"class":75},[32,795,652],{"class":71},[32,797,778],{"class":75},[32,799,729],{"class":64},[32,801,732],{"class":75},[32,803,735],{"class":64},[32,805,738],{"class":71},[32,807,808],{"class":64}," &&",[32,810,811],{"class":75}," y ",[32,813,735],{"class":64},[32,815,738],{"class":71},[32,817,741],{"class":64},[32,819,820],{"class":332}," 'Q1'",[32,822,376],{"class":75},[32,824,825,827,829,831,833,835,837,839,841,843,845,847,849,851,853,856],{"class":34,"line":146},[32,826,697],{"class":75},[32,828,652],{"class":71},[32,830,655],{"class":75},[32,832,652],{"class":71},[32,834,778],{"class":75},[32,836,729],{"class":64},[32,838,732],{"class":75},[32,840,76],{"class":64},[32,842,738],{"class":71},[32,844,808],{"class":64},[32,846,811],{"class":75},[32,848,735],{"class":64},[32,850,738],{"class":71},[32,852,741],{"class":64},[32,854,855],{"class":332}," 'Q2'",[32,857,376],{"class":75},[32,859,860,862,864,866,868,870,872,874,876,878,880,882,884,886,888,891],{"class":34,"line":162},[32,861,697],{"class":75},[32,863,652],{"class":71},[32,865,655],{"class":75},[32,867,652],{"class":71},[32,869,778],{"class":75},[32,871,729],{"class":64},[32,873,732],{"class":75},[32,875,76],{"class":64},[32,877,738],{"class":71},[32,879,808],{"class":64},[32,881,811],{"class":75},[32,883,76],{"class":64},[32,885,738],{"class":71},[32,887,741],{"class":64},[32,889,890],{"class":332}," 'Q3'",[32,892,376],{"class":75},[32,894,895,897,899,902],{"class":34,"line":167},[32,896,513],{"class":75},[32,898,307],{"class":64},[32,900,901],{"class":332}," 'Q4'",[32,903,376],{"class":75},[32,905,906],{"class":34,"line":172},[32,907,398],{"class":75},[32,909,910],{"class":34,"line":196},[32,911,58],{"emptyLinePlaceholder":57},[32,913,914],{"class":34,"line":207},[32,915,916],{"class":38},"\u002F\u002F Type + destructuring patterns:\n",[32,918,919,921,923,926],{"class":34,"line":221},[32,920,65],{"class":64},[32,922,68],{"class":64},[32,924,925],{"class":71}," Shape",[32,927,928],{"class":75}," {}\n",[32,930,931,933,936,939,941,944,947,950,953,956,958,960],{"class":34,"line":226},[32,932,110],{"class":64},[32,934,935],{"class":71}," Circle",[32,937,938],{"class":64}," extends",[32,940,925],{"class":71},[32,942,943],{"class":75}," { ",[32,945,946],{"class":64},"final",[32,948,949],{"class":71}," double",[32,951,952],{"class":75}," r; ",[32,954,955],{"class":71},"Circle",[32,957,153],{"class":75},[32,959,156],{"class":71},[32,961,962],{"class":75},".r); }\n",[32,964,965,967,970,972,974,976,978,980,983,986,988,990,993,995],{"class":34,"line":231},[32,966,110],{"class":64},[32,968,969],{"class":71}," Rectangle",[32,971,938],{"class":64},[32,973,925],{"class":71},[32,975,943],{"class":75},[32,977,946],{"class":64},[32,979,949],{"class":71},[32,981,982],{"class":75}," w, h; ",[32,984,985],{"class":71},"Rectangle",[32,987,153],{"class":75},[32,989,156],{"class":71},[32,991,992],{"class":75},".w, ",[32,994,156],{"class":71},[32,996,997],{"class":75},".h); }\n",[32,999,1000,1002,1005,1007,1009,1011,1013,1015,1018,1021,1023,1025,1028,1030,1033,1035],{"class":34,"line":255},[32,1001,110],{"class":64},[32,1003,1004],{"class":71}," Triangle",[32,1006,938],{"class":64},[32,1008,925],{"class":71},[32,1010,943],{"class":75},[32,1012,946],{"class":64},[32,1014,949],{"class":71},[32,1016,1017],{"class":75}," a, b, c; ",[32,1019,1020],{"class":71},"Triangle",[32,1022,153],{"class":75},[32,1024,156],{"class":71},[32,1026,1027],{"class":75},".a, ",[32,1029,156],{"class":71},[32,1031,1032],{"class":75},".b, ",[32,1034,156],{"class":71},[32,1036,1037],{"class":75},".c); }\n",[32,1039,1040],{"class":34,"line":264},[32,1041,58],{"emptyLinePlaceholder":57},[32,1043,1044,1047,1050,1052,1055,1057,1059,1061],{"class":34,"line":269},[32,1045,1046],{"class":71},"double",[32,1048,1049],{"class":286}," area",[32,1051,153],{"class":75},[32,1053,1054],{"class":71},"Shape",[32,1056,472],{"class":75},[32,1058,307],{"class":64},[32,1060,310],{"class":64},[32,1062,479],{"class":75},[32,1064,1065,1068,1070,1072,1075,1077,1080,1083,1086,1089],{"class":34,"line":274},[32,1066,1067],{"class":71},"  Circle",[32,1069,153],{"class":75},[32,1071,324],{"class":64},[32,1073,1074],{"class":75}," r) ",[32,1076,307],{"class":64},[32,1078,1079],{"class":71}," 3.14159",[32,1081,1082],{"class":64}," *",[32,1084,1085],{"class":75}," r ",[32,1087,1088],{"class":64},"*",[32,1090,1091],{"class":75}," r,\n",[32,1093,1094,1097,1099,1101,1104,1106,1109,1111,1114,1116],{"class":34,"line":280},[32,1095,1096],{"class":71},"  Rectangle",[32,1098,153],{"class":75},[32,1100,324],{"class":64},[32,1102,1103],{"class":75}," w, ",[32,1105,324],{"class":64},[32,1107,1108],{"class":75}," h) ",[32,1110,307],{"class":64},[32,1112,1113],{"class":75}," w ",[32,1115,1088],{"class":64},[32,1117,1118],{"class":75}," h,\n",[32,1120,1121,1124,1126,1128,1131,1133,1136,1138],{"class":34,"line":316},[32,1122,1123],{"class":71},"  Triangle",[32,1125,153],{"class":75},[32,1127,324],{"class":64},[32,1129,1130],{"class":75}," a, ",[32,1132,324],{"class":64},[32,1134,1135],{"class":75}," b, ",[32,1137,324],{"class":64},[32,1139,1140],{"class":75}," c) {\n",[32,1142,1143,1146,1149,1151,1154,1157,1160,1162,1165,1168,1171],{"class":34,"line":351},[32,1144,1145],{"class":64},"    final",[32,1147,1148],{"class":75}," semi ",[32,1150,663],{"class":64},[32,1152,1153],{"class":75}," (a ",[32,1155,1156],{"class":64},"+",[32,1158,1159],{"class":75}," b ",[32,1161,1156],{"class":64},[32,1163,1164],{"class":75}," c) ",[32,1166,1167],{"class":64},"\u002F",[32,1169,1170],{"class":71}," 2",[32,1172,1173],{"class":75},";\n",[32,1175,1176,1179,1182,1184,1186,1189,1192,1194,1196,1198,1201,1203,1205,1207,1210,1213],{"class":34,"line":379},[32,1177,1178],{"class":64},"    return",[32,1180,1181],{"class":75}," (semi ",[32,1183,1088],{"class":64},[32,1185,1181],{"class":75},[32,1187,1188],{"class":64},"-",[32,1190,1191],{"class":75}," a) ",[32,1193,1088],{"class":64},[32,1195,1181],{"class":75},[32,1197,1188],{"class":64},[32,1199,1200],{"class":75}," b) ",[32,1202,1088],{"class":64},[32,1204,1181],{"class":75},[32,1206,1188],{"class":64},[32,1208,1209],{"class":75}," c)).",[32,1211,1212],{"class":286},"abs",[32,1214,93],{"class":75},[32,1216,1217],{"class":34,"line":395},[32,1218,1219],{"class":75},"  }\n",[32,1221,1222],{"class":34,"line":401},[32,1223,398],{"class":75},[32,1225,1226],{"class":34,"line":406},[32,1227,58],{"emptyLinePlaceholder":57},[32,1229,1230],{"class":34,"line":412},[32,1231,1232],{"class":38},"\u002F\u002F `if` with patterns (Dart 3):\n",[32,1234,1235,1238,1241,1243,1245],{"class":34,"line":418},[32,1236,1237],{"class":64},"void",[32,1239,1240],{"class":286}," handleShape",[32,1242,153],{"class":75},[32,1244,1054],{"class":71},[32,1246,1247],{"class":75}," s) {\n",[32,1249,1251,1254,1257,1260,1262,1264,1266,1268,1270,1272,1274,1277],{"class":34,"line":1250},33,[32,1252,1253],{"class":64},"  if",[32,1255,1256],{"class":75}," (s ",[32,1258,1259],{"class":64},"case",[32,1261,935],{"class":71},[32,1263,153],{"class":75},[32,1265,324],{"class":64},[32,1267,1074],{"class":75},[32,1269,729],{"class":64},[32,1271,1085],{"class":75},[32,1273,735],{"class":64},[32,1275,1276],{"class":71}," 100",[32,1278,1279],{"class":75},") {\n",[32,1281,1283,1286,1288,1291,1293,1296,1298],{"class":34,"line":1282},34,[32,1284,1285],{"class":286},"    print",[32,1287,153],{"class":75},[32,1289,1290],{"class":332},"'Large circle: ",[32,1292,336],{"class":332},[32,1294,1295],{"class":71},"r",[32,1297,342],{"class":332},[32,1299,678],{"class":75},[32,1301,1303,1306,1309,1312,1314,1316,1318,1320,1322,1324,1326,1328,1330,1332,1335],{"class":34,"line":1302},35,[32,1304,1305],{"class":75},"  } ",[32,1307,1308],{"class":64},"else",[32,1310,1311],{"class":64}," if",[32,1313,1256],{"class":75},[32,1315,1259],{"class":64},[32,1317,969],{"class":71},[32,1319,153],{"class":75},[32,1321,324],{"class":64},[32,1323,1103],{"class":75},[32,1325,324],{"class":64},[32,1327,1108],{"class":75},[32,1329,729],{"class":64},[32,1331,1113],{"class":75},[32,1333,1334],{"class":64},"==",[32,1336,1337],{"class":75}," h) {\n",[32,1339,1341,1343,1345,1348,1351,1354,1357,1360,1362,1365,1367,1369],{"class":34,"line":1340},36,[32,1342,1285],{"class":286},[32,1344,153],{"class":75},[32,1346,1347],{"class":332},"'Square: ",[32,1349,1350],{"class":332},"${",[32,1352,1353],{"class":71},"w",[32,1355,1356],{"class":332},"}",[32,1358,1359],{"class":332},"x",[32,1361,1350],{"class":332},[32,1363,1364],{"class":71},"h",[32,1366,1356],{"class":332},[32,1368,342],{"class":332},[32,1370,678],{"class":75},[32,1372,1374],{"class":34,"line":1373},37,[32,1375,1219],{"class":75},[32,1377,1379],{"class":34,"line":1378},38,[32,1380,99],{"class":75},[32,1382,1384],{"class":34,"line":1383},39,[32,1385,58],{"emptyLinePlaceholder":57},[32,1387,1389],{"class":34,"line":1388},40,[32,1390,1391],{"class":38},"\u002F\u002F Map pattern (destructuring by key):\n",[32,1393,1395,1398],{"class":34,"line":1394},41,[32,1396,1397],{"class":64},"switch",[32,1399,1400],{"class":75}," (json) {\n",[32,1402,1404,1407,1410,1413,1416,1419,1421,1424,1426,1429,1431,1434,1436,1438,1441],{"class":34,"line":1403},42,[32,1405,1406],{"class":64},"  case",[32,1408,1409],{"class":75}," {",[32,1411,1412],{"class":332},"'type'",[32,1414,1415],{"class":64},":",[32,1417,1418],{"class":332}," 'point'",[32,1420,672],{"class":75},[32,1422,1423],{"class":332},"'x'",[32,1425,1415],{"class":64},[32,1427,1428],{"class":71}," int",[32,1430,655],{"class":75},[32,1432,1433],{"class":332},"'y'",[32,1435,1415],{"class":64},[32,1437,1428],{"class":71},[32,1439,1440],{"class":75}," y}",[32,1442,1443],{"class":64},":\n",[32,1445,1447,1449,1451,1454,1456,1458,1460,1462,1465,1468],{"class":34,"line":1446},43,[32,1448,1285],{"class":286},[32,1450,153],{"class":75},[32,1452,1453],{"class":332},"'Point at (",[32,1455,336],{"class":332},[32,1457,1359],{"class":71},[32,1459,672],{"class":332},[32,1461,336],{"class":332},[32,1463,1464],{"class":71},"y",[32,1466,1467],{"class":332},")'",[32,1469,678],{"class":75},[32,1471,1473,1475,1477,1479,1481,1484,1486,1489,1491,1493,1496],{"class":34,"line":1472},44,[32,1474,1406],{"class":64},[32,1476,1409],{"class":75},[32,1478,1412],{"class":332},[32,1480,1415],{"class":64},[32,1482,1483],{"class":332}," 'circle'",[32,1485,672],{"class":75},[32,1487,1488],{"class":332},"'radius'",[32,1490,1415],{"class":64},[32,1492,949],{"class":71},[32,1494,1495],{"class":75}," r}",[32,1497,1443],{"class":64},[32,1499,1501,1503,1505,1508,1510,1512,1514],{"class":34,"line":1500},45,[32,1502,1285],{"class":286},[32,1504,153],{"class":75},[32,1506,1507],{"class":332},"'Circle radius ",[32,1509,336],{"class":332},[32,1511,1295],{"class":71},[32,1513,342],{"class":332},[32,1515,678],{"class":75},[32,1517,1519,1521,1523,1525,1527,1529,1532],{"class":34,"line":1518},46,[32,1520,1406],{"class":64},[32,1522,1409],{"class":75},[32,1524,1412],{"class":332},[32,1526,1415],{"class":64},[32,1528,201],{"class":71},[32,1530,1531],{"class":75}," type}",[32,1533,1443],{"class":64},[32,1535,1537,1539,1541,1544,1546,1549,1551],{"class":34,"line":1536},47,[32,1538,1285],{"class":286},[32,1540,153],{"class":75},[32,1542,1543],{"class":332},"'Unknown type: ",[32,1545,336],{"class":332},[32,1547,1548],{"class":71},"type",[32,1550,342],{"class":332},[32,1552,678],{"class":75},[32,1554,1556],{"class":34,"line":1555},48,[32,1557,99],{"class":75},[14,1559,1561],{"id":1560},"switch-expressions-vs-statements","Switch Expressions vs Statements",[19,1563,1564],{"language":21},[23,1565,1567],{"className":25,"code":1566,"language":21,"meta":27,"style":27},"\u002F\u002F Switch EXPRESSION — returns a value, no `break`, arms are `=>`:\nfinal status = switch (code) {\n  200 || 201 => 'success',  \u002F\u002F OR pattern: multiple values, one arm\n  400 => 'bad request',\n  401 || 403 => 'auth error',\n  404 => 'not found',\n  >= 500 => 'server error',  \u002F\u002F relational pattern: >= 500\n  _ => 'unknown',\n};\n\n\u002F\u002F Switch STATEMENT — for side effects, `break` required (no implicit fallthrough):\nvoid handle(int code) {\n  switch (code) {\n    case 200:\n    case 201:  \u002F\u002F empty case falls through to next (only for empty cases)\n      print('Success');\n      break;\n    case 404:\n      print('Not found');\n      break;\n    default:\n      print('Unknown');\n  }\n}\n\n\u002F\u002F ❌ Anti-pattern: forgetting `break` in a switch statement.\n\u002F\u002F switch (x) { case 1: print('one'); case 2: print('two'); }  \u002F\u002F ✗ compile error\n\u002F\u002F Dart requires break\u002Freturn\u002Fthrow\u002Fcontinue after each non-empty case body.\n\u002F\u002F Only EMPTY cases (no body) fall through to the next.\n",[29,1568,1569,1574,1588,1609,1621,1638,1650,1668,1679,1683,1687,1692,1706,1713,1723,1734,1746,1753,1762,1773,1779,1784,1795,1799,1803,1807,1812,1820,1825],{"__ignoreMap":27},[32,1570,1571],{"class":34,"line":35},[32,1572,1573],{"class":38},"\u002F\u002F Switch EXPRESSION — returns a value, no `break`, arms are `=>`:\n",[32,1575,1576,1578,1581,1583,1585],{"class":34,"line":42},[32,1577,946],{"class":64},[32,1579,1580],{"class":75}," status ",[32,1582,663],{"class":64},[32,1584,310],{"class":64},[32,1586,1587],{"class":75}," (code) {\n",[32,1589,1590,1593,1596,1599,1601,1604,1606],{"class":34,"line":48},[32,1591,1592],{"class":71},"  200",[32,1594,1595],{"class":64}," ||",[32,1597,1598],{"class":71}," 201",[32,1600,741],{"class":64},[32,1602,1603],{"class":332}," 'success'",[32,1605,345],{"class":75},[32,1607,1608],{"class":38},"\u002F\u002F OR pattern: multiple values, one arm\n",[32,1610,1611,1614,1616,1619],{"class":34,"line":54},[32,1612,1613],{"class":71},"  400",[32,1615,741],{"class":64},[32,1617,1618],{"class":332}," 'bad request'",[32,1620,376],{"class":75},[32,1622,1623,1626,1628,1631,1633,1636],{"class":34,"line":61},[32,1624,1625],{"class":71},"  401",[32,1627,1595],{"class":64},[32,1629,1630],{"class":71}," 403",[32,1632,741],{"class":64},[32,1634,1635],{"class":332}," 'auth error'",[32,1637,376],{"class":75},[32,1639,1640,1643,1645,1648],{"class":34,"line":85},[32,1641,1642],{"class":71},"  404",[32,1644,741],{"class":64},[32,1646,1647],{"class":332}," 'not found'",[32,1649,376],{"class":75},[32,1651,1652,1655,1658,1660,1663,1665],{"class":34,"line":96},[32,1653,1654],{"class":64},"  >=",[32,1656,1657],{"class":71}," 500",[32,1659,741],{"class":64},[32,1661,1662],{"class":332}," 'server error'",[32,1664,345],{"class":75},[32,1666,1667],{"class":38},"\u002F\u002F relational pattern: >= 500\n",[32,1669,1670,1672,1674,1677],{"class":34,"line":102},[32,1671,513],{"class":75},[32,1673,307],{"class":64},[32,1675,1676],{"class":332}," 'unknown'",[32,1678,376],{"class":75},[32,1680,1681],{"class":34,"line":107},[32,1682,398],{"class":75},[32,1684,1685],{"class":34,"line":134},[32,1686,58],{"emptyLinePlaceholder":57},[32,1688,1689],{"class":34,"line":146},[32,1690,1691],{"class":38},"\u002F\u002F Switch STATEMENT — for side effects, `break` required (no implicit fallthrough):\n",[32,1693,1694,1696,1699,1701,1703],{"class":34,"line":162},[32,1695,1237],{"class":64},[32,1697,1698],{"class":286}," handle",[32,1700,153],{"class":75},[32,1702,652],{"class":71},[32,1704,1705],{"class":75}," code) {\n",[32,1707,1708,1711],{"class":34,"line":167},[32,1709,1710],{"class":64},"  switch",[32,1712,1587],{"class":75},[32,1714,1715,1718,1721],{"class":34,"line":172},[32,1716,1717],{"class":64},"    case",[32,1719,1720],{"class":71}," 200",[32,1722,1443],{"class":64},[32,1724,1725,1727,1729,1731],{"class":34,"line":196},[32,1726,1717],{"class":64},[32,1728,1598],{"class":71},[32,1730,1415],{"class":64},[32,1732,1733],{"class":38},"  \u002F\u002F empty case falls through to next (only for empty cases)\n",[32,1735,1736,1739,1741,1744],{"class":34,"line":207},[32,1737,1738],{"class":286},"      print",[32,1740,153],{"class":75},[32,1742,1743],{"class":332},"'Success'",[32,1745,678],{"class":75},[32,1747,1748,1751],{"class":34,"line":221},[32,1749,1750],{"class":64},"      break",[32,1752,1173],{"class":75},[32,1754,1755,1757,1760],{"class":34,"line":226},[32,1756,1717],{"class":64},[32,1758,1759],{"class":71}," 404",[32,1761,1443],{"class":64},[32,1763,1764,1766,1768,1771],{"class":34,"line":231},[32,1765,1738],{"class":286},[32,1767,153],{"class":75},[32,1769,1770],{"class":332},"'Not found'",[32,1772,678],{"class":75},[32,1774,1775,1777],{"class":34,"line":255},[32,1776,1750],{"class":64},[32,1778,1173],{"class":75},[32,1780,1781],{"class":34,"line":264},[32,1782,1783],{"class":64},"    default:\n",[32,1785,1786,1788,1790,1793],{"class":34,"line":269},[32,1787,1738],{"class":286},[32,1789,153],{"class":75},[32,1791,1792],{"class":332},"'Unknown'",[32,1794,678],{"class":75},[32,1796,1797],{"class":34,"line":274},[32,1798,1219],{"class":75},[32,1800,1801],{"class":34,"line":280},[32,1802,99],{"class":75},[32,1804,1805],{"class":34,"line":316},[32,1806,58],{"emptyLinePlaceholder":57},[32,1808,1809],{"class":34,"line":351},[32,1810,1811],{"class":38},"\u002F\u002F ❌ Anti-pattern: forgetting `break` in a switch statement.\n",[32,1813,1814,1817],{"class":34,"line":379},[32,1815,1816],{"class":38},"\u002F\u002F switch (x) { case 1: print('one'); case 2: print('two'); }",[32,1818,1819],{"class":38},"  \u002F\u002F ✗ compile error\n",[32,1821,1822],{"class":34,"line":395},[32,1823,1824],{"class":38},"\u002F\u002F Dart requires break\u002Freturn\u002Fthrow\u002Fcontinue after each non-empty case body.\n",[32,1826,1827],{"class":34,"line":401},[32,1828,1829],{"class":38},"\u002F\u002F Only EMPTY cases (no body) fall through to the next.\n",[14,1831,1833,1834,430],{"id":1832},"loop-semantics-capture-foreach-trap","Loop Semantics — Capture & ",[29,1835,1836],{},"forEach",[19,1838,1839],{"language":21},[23,1840,1842],{"className":25,"code":1841,"language":21,"meta":27,"style":27},"\u002F\u002F Dart's `for` loop variable is a SINGLE variable reassigned each iteration\n\u002F\u002F (like JS `var`, NOT like JS `let` or Rust). Closures capture it by reference.\n\n\u002F\u002F ❌ Anti-pattern: closures in a loop all capture the same variable.\nvar callbacks = \u003Cint Function()>[];\nfor (var i = 0; i \u003C 3; i++) {\n  callbacks.add(() => i);\n}\nprint(callbacks.map((f) => f()).toList());  \u002F\u002F [3, 3, 3] — all see final value of i\n\n\u002F\u002F ✓ Correct: capture per-iteration in a `final` local.\nvar callbacksFixed = \u003Cint Function()>[];\nfor (var i = 0; i \u003C 3; i++) {\n  final captured = i;  \u002F\u002F fresh per iteration, immutable\n  callbacksFixed.add(() => captured);\n}\nprint(callbacksFixed.map((f) => f()).toList());  \u002F\u002F [0, 1, 2]\n\n\u002F\u002F `forEach` is a METHOD, not a loop — `continue`\u002F`break` don't work inside it.\n\u002F\u002F ❌ Anti-pattern: using `continue` in `forEach`.\n[1, 2, 3].forEach((x) {\n  \u002F\u002F if (x == 2) continue;  \u002F\u002F ✗ compile error — no continue in a callback\n  if (x == 2) return;  \u002F\u002F ✓ `return` skips this callback invocation (like continue)\n  print(x);  \u002F\u002F 1, 3\n});\n\n\u002F\u002F ✓ For `continue`\u002F`break` semantics, use a real loop:\nfor (var x in [1, 2, 3]) {\n  if (x == 2) continue;\n  print(x);  \u002F\u002F 1, 3\n}\n",[29,1843,1844,1849,1854,1858,1863,1889,1921,1937,1941,1972,1976,1981,2002,2028,2043,2057,2061,2085,2089,2094,2099,2124,2132,2154,2165,2170,2174,2179,2208,2225,2233],{"__ignoreMap":27},[32,1845,1846],{"class":34,"line":35},[32,1847,1848],{"class":38},"\u002F\u002F Dart's `for` loop variable is a SINGLE variable reassigned each iteration\n",[32,1850,1851],{"class":34,"line":42},[32,1852,1853],{"class":38},"\u002F\u002F (like JS `var`, NOT like JS `let` or Rust). Closures capture it by reference.\n",[32,1855,1856],{"class":34,"line":48},[32,1857,58],{"emptyLinePlaceholder":57},[32,1859,1860],{"class":34,"line":54},[32,1861,1862],{"class":38},"\u002F\u002F ❌ Anti-pattern: closures in a loop all capture the same variable.\n",[32,1864,1865,1868,1871,1873,1876,1878,1881,1884,1886],{"class":34,"line":61},[32,1866,1867],{"class":64},"var",[32,1869,1870],{"class":75}," callbacks ",[32,1872,663],{"class":64},[32,1874,1875],{"class":64}," \u003C",[32,1877,652],{"class":71},[32,1879,1880],{"class":71}," Function",[32,1882,1883],{"class":75},"()",[32,1885,735],{"class":64},[32,1887,1888],{"class":75},"[];\n",[32,1890,1891,1894,1896,1898,1901,1903,1905,1908,1910,1913,1916,1919],{"class":34,"line":85},[32,1892,1893],{"class":64},"for",[32,1895,666],{"class":75},[32,1897,1867],{"class":64},[32,1899,1900],{"class":75}," i ",[32,1902,663],{"class":64},[32,1904,738],{"class":71},[32,1906,1907],{"class":75},"; i ",[32,1909,76],{"class":64},[32,1911,1912],{"class":71}," 3",[32,1914,1915],{"class":75},"; i",[32,1917,1918],{"class":64},"++",[32,1920,1279],{"class":75},[32,1922,1923,1926,1929,1932,1934],{"class":34,"line":96},[32,1924,1925],{"class":75},"  callbacks.",[32,1927,1928],{"class":286},"add",[32,1930,1931],{"class":75},"(() ",[32,1933,307],{"class":64},[32,1935,1936],{"class":75}," i);\n",[32,1938,1939],{"class":34,"line":102},[32,1940,99],{"class":75},[32,1942,1943,1946,1949,1952,1955,1957,1960,1963,1966,1969],{"class":34,"line":107},[32,1944,1945],{"class":286},"print",[32,1947,1948],{"class":75},"(callbacks.",[32,1950,1951],{"class":286},"map",[32,1953,1954],{"class":75},"((f) ",[32,1956,307],{"class":64},[32,1958,1959],{"class":286}," f",[32,1961,1962],{"class":75},"()).",[32,1964,1965],{"class":286},"toList",[32,1967,1968],{"class":75},"());  ",[32,1970,1971],{"class":38},"\u002F\u002F [3, 3, 3] — all see final value of i\n",[32,1973,1974],{"class":34,"line":134},[32,1975,58],{"emptyLinePlaceholder":57},[32,1977,1978],{"class":34,"line":146},[32,1979,1980],{"class":38},"\u002F\u002F ✓ Correct: capture per-iteration in a `final` local.\n",[32,1982,1983,1985,1988,1990,1992,1994,1996,1998,2000],{"class":34,"line":162},[32,1984,1867],{"class":64},[32,1986,1987],{"class":75}," callbacksFixed ",[32,1989,663],{"class":64},[32,1991,1875],{"class":64},[32,1993,652],{"class":71},[32,1995,1880],{"class":71},[32,1997,1883],{"class":75},[32,1999,735],{"class":64},[32,2001,1888],{"class":75},[32,2003,2004,2006,2008,2010,2012,2014,2016,2018,2020,2022,2024,2026],{"class":34,"line":167},[32,2005,1893],{"class":64},[32,2007,666],{"class":75},[32,2009,1867],{"class":64},[32,2011,1900],{"class":75},[32,2013,663],{"class":64},[32,2015,738],{"class":71},[32,2017,1907],{"class":75},[32,2019,76],{"class":64},[32,2021,1912],{"class":71},[32,2023,1915],{"class":75},[32,2025,1918],{"class":64},[32,2027,1279],{"class":75},[32,2029,2030,2032,2035,2037,2040],{"class":34,"line":172},[32,2031,137],{"class":64},[32,2033,2034],{"class":75}," captured ",[32,2036,663],{"class":64},[32,2038,2039],{"class":75}," i;  ",[32,2041,2042],{"class":38},"\u002F\u002F fresh per iteration, immutable\n",[32,2044,2045,2048,2050,2052,2054],{"class":34,"line":196},[32,2046,2047],{"class":75},"  callbacksFixed.",[32,2049,1928],{"class":286},[32,2051,1931],{"class":75},[32,2053,307],{"class":64},[32,2055,2056],{"class":75}," captured);\n",[32,2058,2059],{"class":34,"line":207},[32,2060,99],{"class":75},[32,2062,2063,2065,2068,2070,2072,2074,2076,2078,2080,2082],{"class":34,"line":221},[32,2064,1945],{"class":286},[32,2066,2067],{"class":75},"(callbacksFixed.",[32,2069,1951],{"class":286},[32,2071,1954],{"class":75},[32,2073,307],{"class":64},[32,2075,1959],{"class":286},[32,2077,1962],{"class":75},[32,2079,1965],{"class":286},[32,2081,1968],{"class":75},[32,2083,2084],{"class":38},"\u002F\u002F [0, 1, 2]\n",[32,2086,2087],{"class":34,"line":226},[32,2088,58],{"emptyLinePlaceholder":57},[32,2090,2091],{"class":34,"line":231},[32,2092,2093],{"class":38},"\u002F\u002F `forEach` is a METHOD, not a loop — `continue`\u002F`break` don't work inside it.\n",[32,2095,2096],{"class":34,"line":255},[32,2097,2098],{"class":38},"\u002F\u002F ❌ Anti-pattern: using `continue` in `forEach`.\n",[32,2100,2101,2104,2107,2109,2112,2114,2116,2119,2121],{"class":34,"line":264},[32,2102,2103],{"class":75},"[",[32,2105,2106],{"class":71},"1",[32,2108,672],{"class":75},[32,2110,2111],{"class":71},"2",[32,2113,672],{"class":75},[32,2115,669],{"class":71},[32,2117,2118],{"class":75},"].",[32,2120,1836],{"class":286},[32,2122,2123],{"class":75},"((x) {\n",[32,2125,2126,2129],{"class":34,"line":269},[32,2127,2128],{"class":38},"  \u002F\u002F if (x == 2) continue;",[32,2130,2131],{"class":38},"  \u002F\u002F ✗ compile error — no continue in a callback\n",[32,2133,2134,2136,2139,2141,2143,2145,2148,2151],{"class":34,"line":274},[32,2135,1253],{"class":64},[32,2137,2138],{"class":75}," (x ",[32,2140,1334],{"class":64},[32,2142,1170],{"class":71},[32,2144,707],{"class":75},[32,2146,2147],{"class":64},"return",[32,2149,2150],{"class":75},";  ",[32,2152,2153],{"class":38},"\u002F\u002F ✓ `return` skips this callback invocation (like continue)\n",[32,2155,2156,2159,2162],{"class":34,"line":280},[32,2157,2158],{"class":286},"  print",[32,2160,2161],{"class":75},"(x);  ",[32,2163,2164],{"class":38},"\u002F\u002F 1, 3\n",[32,2166,2167],{"class":34,"line":316},[32,2168,2169],{"class":75},"});\n",[32,2171,2172],{"class":34,"line":351},[32,2173,58],{"emptyLinePlaceholder":57},[32,2175,2176],{"class":34,"line":379},[32,2177,2178],{"class":38},"\u002F\u002F ✓ For `continue`\u002F`break` semantics, use a real loop:\n",[32,2180,2181,2183,2185,2187,2189,2192,2195,2197,2199,2201,2203,2205],{"class":34,"line":395},[32,2182,1893],{"class":64},[32,2184,666],{"class":75},[32,2186,1867],{"class":64},[32,2188,732],{"class":75},[32,2190,2191],{"class":64},"in",[32,2193,2194],{"class":75}," [",[32,2196,2106],{"class":71},[32,2198,672],{"class":75},[32,2200,2111],{"class":71},[32,2202,672],{"class":75},[32,2204,669],{"class":71},[32,2206,2207],{"class":75},"]) {\n",[32,2209,2210,2212,2214,2216,2218,2220,2223],{"class":34,"line":401},[32,2211,1253],{"class":64},[32,2213,2138],{"class":75},[32,2215,1334],{"class":64},[32,2217,1170],{"class":71},[32,2219,707],{"class":75},[32,2221,2222],{"class":64},"continue",[32,2224,1173],{"class":75},[32,2226,2227,2229,2231],{"class":34,"line":406},[32,2228,2158],{"class":286},[32,2230,2161],{"class":75},[32,2232,2164],{"class":38},[32,2234,2235],{"class":34,"line":412},[32,2236,99],{"class":75},[14,2238,2240,2243],{"id":2239},"assert-debug-only-invariants",[29,2241,2242],{},"assert"," — Debug-Only Invariants",[19,2245,2246],{"language":21},[23,2247,2249],{"className":25,"code":2248,"language":21,"meta":27,"style":27},"\u002F\u002F assert() runs ONLY in debug (JIT\u002FVM). In AOT (release), it's completely stripped.\n\u002F\u002F Use for development-time invariants — conditions that indicate a bug if false.\n\nvoid transfer(Account from, Account to, int amount) {\n  assert(amount > 0, 'Transfer amount must be positive');\n  assert(from.balance >= amount, 'Insufficient funds — caller should check first');\n  \u002F\u002F These assertions catch programming errors during development.\n  \u002F\u002F In release, they vanish — zero overhead. But the checks are NOT runtime validation.\n\n  \u002F\u002F For user-facing validation, use explicit checks:\n  if (amount \u003C= 0) throw ArgumentError('Amount must be positive: $amount');\n  if (from.balance \u003C amount) throw StateError('Insufficient funds');\n\n  from.debit(amount);\n  to.credit(amount);\n}\n\n\u002F\u002F assert with a lambda body for expensive checks (only evaluated in debug):\nassert(() {\n  _validateInvariants();  \u002F\u002F complex check — stripped in release\n  return true;\n}());\n",[29,2250,2251,2256,2261,2265,2290,2309,2327,2332,2337,2341,2346,2380,2404,2408,2419,2429,2433,2437,2442,2449,2460,2470],{"__ignoreMap":27},[32,2252,2253],{"class":34,"line":35},[32,2254,2255],{"class":38},"\u002F\u002F assert() runs ONLY in debug (JIT\u002FVM). In AOT (release), it's completely stripped.\n",[32,2257,2258],{"class":34,"line":42},[32,2259,2260],{"class":38},"\u002F\u002F Use for development-time invariants — conditions that indicate a bug if false.\n",[32,2262,2263],{"class":34,"line":48},[32,2264,58],{"emptyLinePlaceholder":57},[32,2266,2267,2269,2272,2274,2277,2280,2282,2285,2287],{"class":34,"line":54},[32,2268,1237],{"class":64},[32,2270,2271],{"class":286}," transfer",[32,2273,153],{"class":75},[32,2275,2276],{"class":71},"Account",[32,2278,2279],{"class":75}," from, ",[32,2281,2276],{"class":71},[32,2283,2284],{"class":75}," to, ",[32,2286,652],{"class":71},[32,2288,2289],{"class":75}," amount) {\n",[32,2291,2292,2295,2298,2300,2302,2304,2307],{"class":34,"line":61},[32,2293,2294],{"class":64},"  assert",[32,2296,2297],{"class":75},"(amount ",[32,2299,735],{"class":64},[32,2301,738],{"class":71},[32,2303,672],{"class":75},[32,2305,2306],{"class":332},"'Transfer amount must be positive'",[32,2308,678],{"class":75},[32,2310,2311,2313,2316,2319,2322,2325],{"class":34,"line":85},[32,2312,2294],{"class":64},[32,2314,2315],{"class":75},"(from.balance ",[32,2317,2318],{"class":64},">=",[32,2320,2321],{"class":75}," amount, ",[32,2323,2324],{"class":332},"'Insufficient funds — caller should check first'",[32,2326,678],{"class":75},[32,2328,2329],{"class":34,"line":96},[32,2330,2331],{"class":38},"  \u002F\u002F These assertions catch programming errors during development.\n",[32,2333,2334],{"class":34,"line":102},[32,2335,2336],{"class":38},"  \u002F\u002F In release, they vanish — zero overhead. But the checks are NOT runtime validation.\n",[32,2338,2339],{"class":34,"line":107},[32,2340,58],{"emptyLinePlaceholder":57},[32,2342,2343],{"class":34,"line":134},[32,2344,2345],{"class":38},"  \u002F\u002F For user-facing validation, use explicit checks:\n",[32,2347,2348,2350,2353,2356,2358,2360,2363,2366,2368,2371,2373,2376,2378],{"class":34,"line":146},[32,2349,1253],{"class":64},[32,2351,2352],{"class":75}," (amount ",[32,2354,2355],{"class":64},"\u003C=",[32,2357,738],{"class":71},[32,2359,707],{"class":75},[32,2361,2362],{"class":64},"throw",[32,2364,2365],{"class":71}," ArgumentError",[32,2367,153],{"class":75},[32,2369,2370],{"class":332},"'Amount must be positive: ",[32,2372,336],{"class":332},[32,2374,2375],{"class":71},"amount",[32,2377,342],{"class":332},[32,2379,678],{"class":75},[32,2381,2382,2384,2387,2389,2392,2394,2397,2399,2402],{"class":34,"line":162},[32,2383,1253],{"class":64},[32,2385,2386],{"class":75}," (from.balance ",[32,2388,76],{"class":64},[32,2390,2391],{"class":75}," amount) ",[32,2393,2362],{"class":64},[32,2395,2396],{"class":71}," StateError",[32,2398,153],{"class":75},[32,2400,2401],{"class":332},"'Insufficient funds'",[32,2403,678],{"class":75},[32,2405,2406],{"class":34,"line":167},[32,2407,58],{"emptyLinePlaceholder":57},[32,2409,2410,2413,2416],{"class":34,"line":172},[32,2411,2412],{"class":75},"  from.",[32,2414,2415],{"class":286},"debit",[32,2417,2418],{"class":75},"(amount);\n",[32,2420,2421,2424,2427],{"class":34,"line":196},[32,2422,2423],{"class":75},"  to.",[32,2425,2426],{"class":286},"credit",[32,2428,2418],{"class":75},[32,2430,2431],{"class":34,"line":207},[32,2432,99],{"class":75},[32,2434,2435],{"class":34,"line":221},[32,2436,58],{"emptyLinePlaceholder":57},[32,2438,2439],{"class":34,"line":226},[32,2440,2441],{"class":38},"\u002F\u002F assert with a lambda body for expensive checks (only evaluated in debug):\n",[32,2443,2444,2446],{"class":34,"line":231},[32,2445,2242],{"class":64},[32,2447,2448],{"class":75},"(() {\n",[32,2450,2451,2454,2457],{"class":34,"line":255},[32,2452,2453],{"class":286},"  _validateInvariants",[32,2455,2456],{"class":75},"();  ",[32,2458,2459],{"class":38},"\u002F\u002F complex check — stripped in release\n",[32,2461,2462,2465,2468],{"class":34,"line":264},[32,2463,2464],{"class":64},"  return",[32,2466,2467],{"class":71}," true",[32,2469,1173],{"class":75},[32,2471,2472],{"class":34,"line":269},[32,2473,2474],{"class":75},"}());\n",[14,2476,2478],{"id":2477},"tips-tricks","💡 Tips & Tricks",[2480,2481,2482,2496,2509,2522,2538],"ul",{},[2483,2484,2485,2489,2490,1167,2492,2495],"li",{},[2486,2487,2488],"strong",{},"Idiom",": remove ",[29,2491,429],{},[29,2493,2494],{},"_"," from switches over sealed types and enums — let the compiler enforce exhaustiveness. Adding a new case causes a compile error at every switch, forcing you to handle it. This is Dart 3's most powerful refactoring safety net.",[2483,2497,2498,2500,2501,2504,2505,2508],{},[2486,2499,2488],{},": use switch expressions for value mapping — ",[29,2502,2503],{},"switch (x) { 200 => 'OK', _ => 'ERR' }"," is concise and returns a value. Use for status code mapping, enum-to-string, result unwrapping. Prefer over ",[29,2506,2507],{},"if-else"," chains for multi-way dispatch.",[2483,2510,2511,2513,2514,2517,2518,2521],{},[2486,2512,2488],{},": use patterns for destructuring — ",[29,2515,2516],{},"case Success(:final value)"," extracts ",[29,2519,2520],{},".value"," directly in the switch arm. Eliminates explicit casts and field access. Combines type checking + extraction in one expression.",[2483,2523,2524,2526,2527,2529,2530,2533,2534,2537],{},[2486,2525,2488],{},": use guard clauses (",[29,2528,729],{},") for additional conditions — ",[29,2531,2532],{},"case (int x, int y) when x > 0 && y > 0"," adds a boolean predicate to a pattern. Use for sub-case filtering without nested ",[29,2535,2536],{},"if",".",[2483,2539,2540,2543,2544,2547],{},[2486,2541,2542],{},"Debug",": ",[29,2545,2546],{},"assert(() { _validateInvariants(); return true; }())"," — the lambda body is fully stripped in AOT (including side effects). Use for expensive debug-only validation that must not run in production.",[14,2549,2551],{"id":2550},"️-edge-cases-gotchas","⚠️ Edge Cases & Gotchas",[2480,2553,2554,2587,2605,2621,2631,2647,2671,2697,2711],{},[2483,2555,2556,2543,2562,2565,2566,2568,2569,672,2571,672,2573,2576,2577,2580,2581,672,2584,2537],{},[2486,2557,2558,2559],{},"Conditions must be ",[29,2560,2561],{},"bool",[29,2563,2564],{},"if (x)"," where ",[29,2567,1359],{}," is ",[29,2570,652],{},[29,2572,283],{},[29,2574,2575],{},"List",", or ",[29,2578,2579],{},"null"," is a compile error. Dart has no truthy\u002Ffalsy. Compare explicitly: ",[29,2582,2583],{},"if (x != null)",[29,2585,2586],{},"if (list.isNotEmpty)",[2483,2588,2589,2594,2595,1167,2598,1167,2600,1167,2602,2604],{},[2486,2590,2591,2593],{},[29,2592,1397],{}," doesn't fall through by default",": each non-empty case must end with ",[29,2596,2597],{},"break",[29,2599,2147],{},[29,2601,2362],{},[29,2603,2222],{},". Only empty cases (no body) fall through. Forgetting the terminator is a compile error (unlike C\u002FJava).",[2483,2606,2607,2614,2615,2617,2618,2620],{},[2486,2608,2609,1167,2611,2613],{},[29,2610,429],{},[29,2612,2494],{}," defeats exhaustiveness",": adding ",[29,2616,2494],{}," to a switch over a sealed type makes it non-exhaustive-checked — new subtypes are silently caught by the wildcard. Remove ",[29,2619,2494],{}," for sealed types and enums.",[2483,2622,2623,2628,2629,2537],{},[2486,2624,2625,2627],{},[29,2626,2242],{}," is stripped in AOT",": the entire expression (including side effects) vanishes in release. Never put business logic, side effects, or runtime validation in ",[29,2630,2242],{},[2483,2632,2633,2638,2639,2642,2643,2646],{},[2486,2634,2635,2637],{},[29,2636,1893],{}," loop variable is shared across iterations",": closures capturing ",[29,2640,2641],{},"i"," see the final value. Use ",[29,2644,2645],{},"final captured = i;"," inside the loop body for per-iteration capture.",[2483,2648,2649,2658,2659,2661,2662,2664,2665,2667,2668,2670],{},[2486,2650,2651,2653,2654,1167,2656],{},[29,2652,1836],{}," doesn't support ",[29,2655,2222],{},[29,2657,2597],{},": it's a method taking a callback. Use ",[29,2660,2147],{}," to skip (like ",[29,2663,2222],{},"), but there's no ",[29,2666,2597],{}," equivalent. Use a real ",[29,2669,1893],{}," loop for control flow.",[2483,2672,2673,2543,2683,2686,2687,2568,2689,2692,2693,2696],{},[2486,2674,2675,2678,2679,2682],{},[29,2676,2677],{},"for-in"," on ",[29,2680,2681],{},"Map"," iterates keys",[29,2684,2685],{},"for (var k in map)"," iterates keys (a ",[29,2688,2681],{},[29,2690,2691],{},"Iterable"," of keys). Use ",[29,2694,2695],{},"for (var entry in map.entries)"," for key-value pairs.",[2483,2698,2699,2543,2705,2708,2709,2537],{},[2486,2700,2701,2702,2704],{},"Labeled ",[29,2703,2597],{}," is rarely idiomatic",[29,2706,2707],{},"outer: for (...) { for (...) { break outer; } }"," works but signals overly complex control flow. Extract to a function and use ",[29,2710,2147],{},[2483,2712,2713,2719],{},[2486,2714,2715,2718],{},[29,2716,2717],{},"do-while"," runs at least once",": the body executes before the condition check. Use for read-then-check patterns (e.g., prompt → validate → repeat).",[14,2721,2723],{"id":2722},"spot-the-bug","🧠 Spot the Bug",[2725,2726,2727,2728,2731],"p",{},"A team adds ",[29,2729,2730],{},"Status.cancelled"," to their enum. The UI silently shows \"Completed\" for cancelled orders:",[19,2733,2734],{"language":21},[23,2735,2737],{"className":25,"code":2736,"language":21,"meta":27,"style":27},"enum Status { pending, active, completed, cancelled }\n\nString label(Status s) => switch (s) {\n  Status.pending => 'Pending',\n  Status.active => 'Active',\n  _ => 'Completed',  \u002F\u002F catches both completed AND cancelled\n};\n",[29,2738,2739,2748,2752,2771,2783,2795,2808],{"__ignoreMap":27},[32,2740,2741,2743,2745],{"class":34,"line":35},[32,2742,442],{"class":64},[32,2744,445],{"class":71},[32,2746,2747],{"class":75}," { pending, active, completed, cancelled }\n",[32,2749,2750],{"class":34,"line":42},[32,2751,58],{"emptyLinePlaceholder":57},[32,2753,2754,2756,2759,2761,2763,2765,2767,2769],{"class":34,"line":48},[32,2755,283],{"class":71},[32,2757,2758],{"class":286}," label",[32,2760,153],{"class":75},[32,2762,469],{"class":71},[32,2764,472],{"class":75},[32,2766,307],{"class":64},[32,2768,310],{"class":64},[32,2770,479],{"class":75},[32,2772,2773,2775,2777,2779,2781],{"class":34,"line":54},[32,2774,484],{"class":71},[32,2776,487],{"class":75},[32,2778,307],{"class":64},[32,2780,492],{"class":332},[32,2782,376],{"class":75},[32,2784,2785,2787,2789,2791,2793],{"class":34,"line":61},[32,2786,484],{"class":71},[32,2788,501],{"class":75},[32,2790,307],{"class":64},[32,2792,506],{"class":332},[32,2794,376],{"class":75},[32,2796,2797,2799,2801,2803,2805],{"class":34,"line":85},[32,2798,513],{"class":75},[32,2800,307],{"class":64},[32,2802,518],{"class":332},[32,2804,345],{"class":75},[32,2806,2807],{"class":38},"\u002F\u002F catches both completed AND cancelled\n",[32,2809,2810],{"class":34,"line":96},[32,2811,398],{"class":75},[2725,2813,2814],{},"Why is this a silent bug, and how to prevent it permanently?",[2816,2817,2818,2822,2834,2840,2929,2944],"details",{},[2819,2820,2821],"summary",{},"Answer",[2725,2823,426,2824,2826,2827,2829,2830,2833],{},[29,2825,2494],{}," (wildcard) catches every unhandled case — including the newly added ",[29,2828,2730],{},". It returns ",[29,2831,2832],{},"'Completed'"," for cancelled orders, which is semantically wrong. The wildcard makes the switch non-exhaustive-checked, so the compiler can't flag the missing case.",[2725,2835,2836,2837,2839],{},"The fix — remove ",[29,2838,2494],{},", handle every case explicitly:",[23,2841,2843],{"className":25,"code":2842,"language":21,"meta":27,"style":27},"enum Status { pending, active, completed, cancelled }\n\nString label(Status s) => switch (s) {\n  Status.pending => 'Pending',\n  Status.active => 'Active',\n  Status.completed => 'Completed',\n  Status.cancelled => 'Cancelled',\n};\n",[29,2844,2845,2853,2857,2875,2887,2899,2911,2925],{"__ignoreMap":27},[32,2846,2847,2849,2851],{"class":34,"line":35},[32,2848,442],{"class":64},[32,2850,445],{"class":71},[32,2852,2747],{"class":75},[32,2854,2855],{"class":34,"line":42},[32,2856,58],{"emptyLinePlaceholder":57},[32,2858,2859,2861,2863,2865,2867,2869,2871,2873],{"class":34,"line":48},[32,2860,283],{"class":71},[32,2862,2758],{"class":286},[32,2864,153],{"class":75},[32,2866,469],{"class":71},[32,2868,472],{"class":75},[32,2870,307],{"class":64},[32,2872,310],{"class":64},[32,2874,479],{"class":75},[32,2876,2877,2879,2881,2883,2885],{"class":34,"line":54},[32,2878,484],{"class":71},[32,2880,487],{"class":75},[32,2882,307],{"class":64},[32,2884,492],{"class":332},[32,2886,376],{"class":75},[32,2888,2889,2891,2893,2895,2897],{"class":34,"line":61},[32,2890,484],{"class":71},[32,2892,501],{"class":75},[32,2894,307],{"class":64},[32,2896,506],{"class":332},[32,2898,376],{"class":75},[32,2900,2901,2903,2905,2907,2909],{"class":34,"line":85},[32,2902,484],{"class":71},[32,2904,600],{"class":75},[32,2906,307],{"class":64},[32,2908,518],{"class":332},[32,2910,376],{"class":75},[32,2912,2913,2915,2918,2920,2923],{"class":34,"line":96},[32,2914,484],{"class":71},[32,2916,2917],{"class":75},".cancelled ",[32,2919,307],{"class":64},[32,2921,2922],{"class":332}," 'Cancelled'",[32,2924,376],{"class":75},[32,2926,2927],{"class":34,"line":102},[32,2928,398],{"class":75},[2725,2930,2931,2932,2935,2936,2939,2940,2943],{},"Now if ",[29,2933,2934],{},"Status.shipped"," is added later, this switch becomes a ",[2486,2937,2938],{},"compile error",": \"The switch expression does not exhaustively cover all possible cases.\" The compiler forces you to handle ",[29,2941,2942],{},"shipped"," — no silent bugs.",[2725,2945,2946,2947,2956],{},"The rule: ",[2486,2948,2949,2950,2952,2953,2955],{},"never use ",[29,2951,2494],{}," or ",[29,2954,429],{}," in switches over enums or sealed types."," Let exhaustiveness checking be your safety net. The wildcard is acceptable for open types (int, String) where you can't enumerate all cases.",[2958,2959,2960],"style",{},"html pre.shiki code .sdCPZ, html code.shiki .sdCPZ{--shiki-default:#6A737D;--shiki-github-dark:#6A737D}html pre.shiki code .svdQ7, html code.shiki .svdQ7{--shiki-default:#D73A49;--shiki-github-dark:#F97583}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}html pre.shiki code .ssxIu, html code.shiki .ssxIu{--shiki-default:#24292E;--shiki-github-dark:#E1E4E8}html pre.shiki code .sIsaT, html code.shiki .sIsaT{--shiki-default:#6F42C1;--shiki-github-dark:#B392F0}html pre.shiki code .sJ6F3, html code.shiki .sJ6F3{--shiki-default:#032F62;--shiki-github-dark:#9ECBFF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}html.github-dark .shiki span {color: var(--shiki-github-dark);background: var(--shiki-github-dark-bg);font-style: var(--shiki-github-dark-font-style);font-weight: var(--shiki-github-dark-font-weight);text-decoration: var(--shiki-github-dark-text-decoration);}",{"title":27,"searchDepth":42,"depth":42,"links":2962},[2963,2967,2968,2969,2971,2973,2974,2975],{"id":16,"depth":42,"text":17,"children":2964},[2965],{"id":425,"depth":48,"text":2966},"The default Trap",{"id":623,"depth":42,"text":624},{"id":1560,"depth":42,"text":1561},{"id":1832,"depth":42,"text":2970},"Loop Semantics — Capture & forEach Trap",{"id":2239,"depth":42,"text":2972},"assert — Debug-Only Invariants",{"id":2477,"depth":42,"text":2478},{"id":2550,"depth":42,"text":2551},{"id":2722,"depth":42,"text":2723},"Deep-dive into Dart 3 exhaustive switches, sealed class patterns, record destructuring, guard clauses, and control-flow edge cases. Code-first engineering reference.","md",{},"\u002Fdart\u002F04-control-flow",{"title":5,"description":2976},"dart\u002F04-control-flow","BMbla2GEPO63k_jplXpE23R_uqshXi_wEEhHAUmRus4",1789924647673]