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