[{"data":1,"prerenderedAt":3832},["ShallowReactive",2],{"page-\u002Fscala\u002F03-functions":3},{"id":4,"title":5,"body":6,"description":3825,"extension":3826,"meta":3827,"navigation":94,"path":3828,"seo":3829,"stem":3830,"__hash__":3831},"content\u002Fscala\u002F03-functions.md","Scala — Functions, Closures & Compile-Time Desugaring",{"type":7,"value":8,"toc":3807},"minimark",[9,14,19,362,366,697,701,1118,1122,1477,1491,1913,1921,2347,2354,2720,2734,3116,3120,3391,3395,3421,3434,3578,3596,3600,3610,3690,3709,3719,3723,3734,3803],[10,11,13],"h1",{"id":12},"_03-functions-closures-compile-time-desugaring","03 — Functions, Closures & Compile-Time Desugaring",[15,16,18],"h2",{"id":17},"function-types-jvm-representation","Function Types — JVM Representation",[20,21,23],"code-wrapper",{"language":22},"scala",[24,25,29],"pre",{"className":26,"code":27,"language":22,"meta":28,"style":28},"language-scala shiki shiki-themes github-light github-dark","\u002F\u002F Function1[A, B] is a trait with a single abstract method:\n\u002F\u002F   trait Function1[-A, +B]:\n\u002F\u002F     def apply(v1: A): B\n\u002F\u002F\n\u002F\u002F At the bytecode level: a lambda (x => x * 2) compiles to:\n\u002F\u002F   1. A synthetic class extending Function1$mcII$sp (specialized for Int→Int)\n\u002F\u002F      → if no specialization: plain Function1 with Object apply(Object)\n\u002F\u002F   2. INVOKEDYNAMIC in Scala 3 (SAM closure via LambdaMetafactory)\n\u002F\u002F      → JVM generates the impl class at runtime, same as Java lambdas\n\nval double: Int => Int = x => x * 2       \u002F\u002F → Function1[Int, Int]\n\u002F\u002F double.apply(5)                         \u002F\u002F → the actual call\n\u002F\u002F double(5)                               \u002F\u002F sugar for .apply(5)\n\n\u002F\u002F Function types up to Function22 exist as named traits.\n\u002F\u002F Beyond 22 params: Scala 3 uses FunctionXXL (uses Object[] internally, not typed)\nval complex: (Int, String, Boolean) => Double = (i, s, b) => if b then i * s.length.toDouble else 0.0\n\n\u002F\u002F Scala 3: dependent function types — return type depends on input value\ntrait Codec:\n  type Repr\n  def encode(r: Repr): Array[Byte]\ndef process(c: Codec)(r: c.Repr): Array[Byte] = c.encode(r)  \u002F\u002F c.Repr is path-dependent\n","",[30,31,32,41,47,53,59,65,71,77,83,89,96,141,150,159,164,170,176,241,246,252,264,273,311],"code",{"__ignoreMap":28},[33,34,37],"span",{"class":35,"line":36},"line",1,[33,38,40],{"class":39},"sdCPZ","\u002F\u002F Function1[A, B] is a trait with a single abstract method:\n",[33,42,44],{"class":35,"line":43},2,[33,45,46],{"class":39},"\u002F\u002F   trait Function1[-A, +B]:\n",[33,48,50],{"class":35,"line":49},3,[33,51,52],{"class":39},"\u002F\u002F     def apply(v1: A): B\n",[33,54,56],{"class":35,"line":55},4,[33,57,58],{"class":39},"\u002F\u002F\n",[33,60,62],{"class":35,"line":61},5,[33,63,64],{"class":39},"\u002F\u002F At the bytecode level: a lambda (x => x * 2) compiles to:\n",[33,66,68],{"class":35,"line":67},6,[33,69,70],{"class":39},"\u002F\u002F   1. A synthetic class extending Function1$mcII$sp (specialized for Int→Int)\n",[33,72,74],{"class":35,"line":73},7,[33,75,76],{"class":39},"\u002F\u002F      → if no specialization: plain Function1 with Object apply(Object)\n",[33,78,80],{"class":35,"line":79},8,[33,81,82],{"class":39},"\u002F\u002F   2. INVOKEDYNAMIC in Scala 3 (SAM closure via LambdaMetafactory)\n",[33,84,86],{"class":35,"line":85},9,[33,87,88],{"class":39},"\u002F\u002F      → JVM generates the impl class at runtime, same as Java lambdas\n",[33,90,92],{"class":35,"line":91},10,[33,93,95],{"emptyLinePlaceholder":94},true,"\n",[33,97,99,103,107,110,114,117,119,122,126,129,131,134,138],{"class":35,"line":98},11,[33,100,102],{"class":101},"svdQ7","val",[33,104,106],{"class":105},"sCrzJ"," double",[33,108,109],{"class":101},":",[33,111,113],{"class":112},"sIsaT"," Int",[33,115,116],{"class":101}," =>",[33,118,113],{"class":112},[33,120,121],{"class":101}," =",[33,123,125],{"class":124},"ssxIu"," x ",[33,127,128],{"class":101},"=>",[33,130,125],{"class":124},[33,132,133],{"class":101},"*",[33,135,137],{"class":136},"snvgF"," 2",[33,139,140],{"class":39},"       \u002F\u002F → Function1[Int, Int]\n",[33,142,144,147],{"class":35,"line":143},12,[33,145,146],{"class":39},"\u002F\u002F double.apply(5)",[33,148,149],{"class":39},"                         \u002F\u002F → the actual call\n",[33,151,153,156],{"class":35,"line":152},13,[33,154,155],{"class":39},"\u002F\u002F double(5)",[33,157,158],{"class":39},"                               \u002F\u002F sugar for .apply(5)\n",[33,160,162],{"class":35,"line":161},14,[33,163,95],{"emptyLinePlaceholder":94},[33,165,167],{"class":35,"line":166},15,[33,168,169],{"class":39},"\u002F\u002F Function types up to Function22 exist as named traits.\n",[33,171,173],{"class":35,"line":172},16,[33,174,175],{"class":39},"\u002F\u002F Beyond 22 params: Scala 3 uses FunctionXXL (uses Object[] internally, not typed)\n",[33,177,179,181,184,186,189,192,195,198,200,203,206,208,211,213,216,218,221,224,227,230,232,235,238],{"class":35,"line":178},17,[33,180,102],{"class":101},[33,182,183],{"class":105}," complex",[33,185,109],{"class":101},[33,187,188],{"class":124}," (",[33,190,191],{"class":112},"Int",[33,193,194],{"class":124},", ",[33,196,197],{"class":112},"String",[33,199,194],{"class":124},[33,201,202],{"class":112},"Boolean",[33,204,205],{"class":124},") ",[33,207,128],{"class":101},[33,209,210],{"class":112}," Double",[33,212,121],{"class":101},[33,214,215],{"class":124}," (i, s, b) ",[33,217,128],{"class":101},[33,219,220],{"class":101}," if",[33,222,223],{"class":124}," b ",[33,225,226],{"class":101},"then",[33,228,229],{"class":124}," i ",[33,231,133],{"class":101},[33,233,234],{"class":124}," s.length.toDouble ",[33,236,237],{"class":101},"else",[33,239,240],{"class":136}," 0.0\n",[33,242,244],{"class":35,"line":243},18,[33,245,95],{"emptyLinePlaceholder":94},[33,247,249],{"class":35,"line":248},19,[33,250,251],{"class":39},"\u002F\u002F Scala 3: dependent function types — return type depends on input value\n",[33,253,255,258,261],{"class":35,"line":254},20,[33,256,257],{"class":101},"trait",[33,259,260],{"class":112}," Codec",[33,262,263],{"class":101},":\n",[33,265,267,270],{"class":35,"line":266},21,[33,268,269],{"class":101},"  type",[33,271,272],{"class":112}," Repr\n",[33,274,276,279,282,285,288,291,294,297,299,302,305,308],{"class":35,"line":275},22,[33,277,278],{"class":101},"  def",[33,280,281],{"class":112}," encode",[33,283,284],{"class":124},"(",[33,286,287],{"class":105},"r",[33,289,290],{"class":124},": ",[33,292,293],{"class":112},"Repr",[33,295,296],{"class":124},")",[33,298,109],{"class":101},[33,300,301],{"class":112}," Array",[33,303,304],{"class":124},"[",[33,306,307],{"class":112},"Byte",[33,309,310],{"class":124},"]\n",[33,312,314,317,320,322,325,327,330,333,335,338,340,342,344,346,348,350,353,356,359],{"class":35,"line":313},23,[33,315,316],{"class":101},"def",[33,318,319],{"class":112}," process",[33,321,284],{"class":124},[33,323,324],{"class":105},"c",[33,326,290],{"class":124},[33,328,329],{"class":112},"Codec",[33,331,332],{"class":124},")(",[33,334,287],{"class":105},[33,336,337],{"class":124},": c.",[33,339,293],{"class":112},[33,341,296],{"class":124},[33,343,109],{"class":101},[33,345,301],{"class":112},[33,347,304],{"class":124},[33,349,307],{"class":112},[33,351,352],{"class":124},"] ",[33,354,355],{"class":101},"=",[33,357,358],{"class":124}," c.encode(r)  ",[33,360,361],{"class":39},"\u002F\u002F c.Repr is path-dependent\n",[15,363,365],{"id":364},"closures-capture-semantics-allocation","Closures — Capture Semantics & Allocation",[20,367,368],{"language":22},[24,369,371],{"className":26,"code":370,"language":22,"meta":28,"style":28},"\u002F\u002F A closure captures free variables from the enclosing scope.\n\u002F\u002F Captured vars → stored as fields in the lambda's synthetic class.\n\u002F\u002F Captured vals → may be inlined or stored as fields.\n\ndef makeCounter(start: Int): () => Int =\n  var count = start                        \u002F\u002F mutable — captured by reference\n  () =>                                    \u002F\u002F closure captures 'count' as a field\n    count += 1                             \u002F\u002F reads AND writes the captured var\n    count\n\nval counter = makeCounter(0)               \u002F\u002F 1 allocation: the closure object\ncounter()                                  \u002F\u002F → 1, reads\u002Fwrites count field on closure\ncounter()                                  \u002F\u002F → 2\n\n\u002F\u002F ❌ ANTI-PATTERN: closure capturing 'this' in a hot loop\nclass Processor:\n  def process(items: List[Int]): List[Int] =\n    items.map(x => transform(x))           \u002F\u002F closure captures 'this' → allocates per call\n  def transform(x: Int): Int = x * 2\n\n\u002F\u002F ✅ CORRECT: hoist method reference, avoid closure allocation\nclass Processor:\n  def process(items: List[Int]): List[Int] =\n    items.map(transform)                   \u002F\u002F method reference: eta-expansion creates ONE Function1\n  def transform(x: Int): Int = x * 2       \u002F\u002F   reused across all elements (in Scala 3 with -opt)\n",[30,372,373,378,383,388,392,422,438,448,462,467,471,492,500,507,511,516,526,563,576,607,611,616,624,656,665],{"__ignoreMap":28},[33,374,375],{"class":35,"line":36},[33,376,377],{"class":39},"\u002F\u002F A closure captures free variables from the enclosing scope.\n",[33,379,380],{"class":35,"line":43},[33,381,382],{"class":39},"\u002F\u002F Captured vars → stored as fields in the lambda's synthetic class.\n",[33,384,385],{"class":35,"line":49},[33,386,387],{"class":39},"\u002F\u002F Captured vals → may be inlined or stored as fields.\n",[33,389,390],{"class":35,"line":55},[33,391,95],{"emptyLinePlaceholder":94},[33,393,394,396,399,401,404,406,408,410,412,415,417,419],{"class":35,"line":61},[33,395,316],{"class":101},[33,397,398],{"class":112}," makeCounter",[33,400,284],{"class":124},[33,402,403],{"class":105},"start",[33,405,290],{"class":124},[33,407,191],{"class":112},[33,409,296],{"class":124},[33,411,109],{"class":101},[33,413,414],{"class":124}," () ",[33,416,128],{"class":101},[33,418,113],{"class":112},[33,420,421],{"class":101}," =\n",[33,423,424,427,430,432,435],{"class":35,"line":67},[33,425,426],{"class":101},"  var",[33,428,429],{"class":105}," count",[33,431,121],{"class":101},[33,433,434],{"class":124}," start                        ",[33,436,437],{"class":39},"\u002F\u002F mutable — captured by reference\n",[33,439,440,443,445],{"class":35,"line":73},[33,441,442],{"class":124},"  () ",[33,444,128],{"class":101},[33,446,447],{"class":39},"                                    \u002F\u002F closure captures 'count' as a field\n",[33,449,450,453,456,459],{"class":35,"line":79},[33,451,452],{"class":124},"    count ",[33,454,455],{"class":101},"+=",[33,457,458],{"class":136}," 1",[33,460,461],{"class":39},"                             \u002F\u002F reads AND writes the captured var\n",[33,463,464],{"class":35,"line":85},[33,465,466],{"class":124},"    count\n",[33,468,469],{"class":35,"line":91},[33,470,95],{"emptyLinePlaceholder":94},[33,472,473,475,478,480,483,486,489],{"class":35,"line":98},[33,474,102],{"class":101},[33,476,477],{"class":105}," counter",[33,479,121],{"class":101},[33,481,482],{"class":124}," makeCounter(",[33,484,485],{"class":136},"0",[33,487,488],{"class":124},")               ",[33,490,491],{"class":39},"\u002F\u002F 1 allocation: the closure object\n",[33,493,494,497],{"class":35,"line":143},[33,495,496],{"class":124},"counter()                                  ",[33,498,499],{"class":39},"\u002F\u002F → 1, reads\u002Fwrites count field on closure\n",[33,501,502,504],{"class":35,"line":152},[33,503,496],{"class":124},[33,505,506],{"class":39},"\u002F\u002F → 2\n",[33,508,509],{"class":35,"line":161},[33,510,95],{"emptyLinePlaceholder":94},[33,512,513],{"class":35,"line":166},[33,514,515],{"class":39},"\u002F\u002F ❌ ANTI-PATTERN: closure capturing 'this' in a hot loop\n",[33,517,518,521,524],{"class":35,"line":172},[33,519,520],{"class":101},"class",[33,522,523],{"class":112}," Processor",[33,525,263],{"class":101},[33,527,528,530,532,534,537,539,542,544,546,549,551,554,556,558,560],{"class":35,"line":178},[33,529,278],{"class":101},[33,531,319],{"class":112},[33,533,284],{"class":124},[33,535,536],{"class":105},"items",[33,538,290],{"class":124},[33,540,541],{"class":112},"List",[33,543,304],{"class":124},[33,545,191],{"class":112},[33,547,548],{"class":124},"])",[33,550,109],{"class":101},[33,552,553],{"class":112}," List",[33,555,304],{"class":124},[33,557,191],{"class":112},[33,559,352],{"class":124},[33,561,562],{"class":101},"=\n",[33,564,565,568,570,573],{"class":35,"line":243},[33,566,567],{"class":124},"    items.map(x ",[33,569,128],{"class":101},[33,571,572],{"class":124}," transform(x))           ",[33,574,575],{"class":39},"\u002F\u002F closure captures 'this' → allocates per call\n",[33,577,578,580,583,585,588,590,592,594,596,598,600,602,604],{"class":35,"line":248},[33,579,278],{"class":101},[33,581,582],{"class":112}," transform",[33,584,284],{"class":124},[33,586,587],{"class":105},"x",[33,589,290],{"class":124},[33,591,191],{"class":112},[33,593,296],{"class":124},[33,595,109],{"class":101},[33,597,113],{"class":112},[33,599,121],{"class":101},[33,601,125],{"class":124},[33,603,133],{"class":101},[33,605,606],{"class":136}," 2\n",[33,608,609],{"class":35,"line":254},[33,610,95],{"emptyLinePlaceholder":94},[33,612,613],{"class":35,"line":266},[33,614,615],{"class":39},"\u002F\u002F ✅ CORRECT: hoist method reference, avoid closure allocation\n",[33,617,618,620,622],{"class":35,"line":275},[33,619,520],{"class":101},[33,621,523],{"class":112},[33,623,263],{"class":101},[33,625,626,628,630,632,634,636,638,640,642,644,646,648,650,652,654],{"class":35,"line":313},[33,627,278],{"class":101},[33,629,319],{"class":112},[33,631,284],{"class":124},[33,633,536],{"class":105},[33,635,290],{"class":124},[33,637,541],{"class":112},[33,639,304],{"class":124},[33,641,191],{"class":112},[33,643,548],{"class":124},[33,645,109],{"class":101},[33,647,553],{"class":112},[33,649,304],{"class":124},[33,651,191],{"class":112},[33,653,352],{"class":124},[33,655,562],{"class":101},[33,657,659,662],{"class":35,"line":658},24,[33,660,661],{"class":124},"    items.map(transform)                   ",[33,663,664],{"class":39},"\u002F\u002F method reference: eta-expansion creates ONE Function1\n",[33,666,668,670,672,674,676,678,680,682,684,686,688,690,692,694],{"class":35,"line":667},25,[33,669,278],{"class":101},[33,671,582],{"class":112},[33,673,284],{"class":124},[33,675,587],{"class":105},[33,677,290],{"class":124},[33,679,191],{"class":112},[33,681,296],{"class":124},[33,683,109],{"class":101},[33,685,113],{"class":112},[33,687,121],{"class":101},[33,689,125],{"class":124},[33,691,133],{"class":101},[33,693,137],{"class":136},[33,695,696],{"class":39},"       \u002F\u002F   reused across all elements (in Scala 3 with -opt)\n",[15,698,700],{"id":699},"higher-order-functions-real-world-pipeline","Higher-Order Functions — Real-World Pipeline",[20,702,703],{"language":22},[24,704,706],{"className":26,"code":705,"language":22,"meta":28,"style":28},"\u002F\u002F Production-grade data pipeline: streaming log analysis with function composition\nimport scala.util.Using\n\nfinal case class LogEntry(ts: Long, level: String, msg: String)\n\nobject LogPipeline:\n  \u002F\u002F Function composition with andThen \u002F compose — builds a single pipeline\n  type LogFilter = LogEntry => Boolean\n  type LogTransform = LogEntry => LogEntry\n\n  val errorFilter: LogFilter = _.level == \"ERROR\"\n  val enrich: LogTransform = e => e.copy(msg = s\"[svc] ${e.msg}\")\n\n  \u002F\u002F andThen: (f andThen g)(x) = g(f(x)) — left-to-right reading\n  \u002F\u002F compose: (f compose g)(x) = f(g(x)) — right-to-left\n  val pipeline: LogFilter = errorFilter\n  val transform: LogTransform = enrich\n\n  def process(entries: List[LogEntry]): List[String] =\n    entries\n      .filter(pipeline)                    \u002F\u002F LogFilter: LogEntry => Boolean\n      .map(transform)                      \u002F\u002F LogTransform: LogEntry => LogEntry\n      .map(_.msg)                          \u002F\u002F extract message\n      .scanLeft(\"\")(_ + \"\\n\" + _)          \u002F\u002F accumulate with prefix\n      .drop(1)                             \u002F\u002F remove initial \"\"\n\n  \u002F\u002F Partial application for reusable, configurable components\n  def filterByLevel(level: String): LogFilter = _.level == level\n  val warnFilter = filterByLevel(\"WARN\")   \u002F\u002F partial application → reusable filter\n",[30,707,708,713,732,736,781,785,795,800,816,832,836,860,897,901,906,911,927,942,946,980,985,993,1001,1009,1040,1054,1059,1065,1096],{"__ignoreMap":28},[33,709,710],{"class":35,"line":36},[33,711,712],{"class":39},"\u002F\u002F Production-grade data pipeline: streaming log analysis with function composition\n",[33,714,715,718,721,724,727,729],{"class":35,"line":43},[33,716,717],{"class":101},"import",[33,719,720],{"class":112}," scala",[33,722,723],{"class":124},".",[33,725,726],{"class":112},"util",[33,728,723],{"class":124},[33,730,731],{"class":112},"Using\n",[33,733,734],{"class":35,"line":49},[33,735,95],{"emptyLinePlaceholder":94},[33,737,738,741,744,747,750,752,755,757,760,762,765,767,769,771,774,776,778],{"class":35,"line":55},[33,739,740],{"class":101},"final",[33,742,743],{"class":101}," case",[33,745,746],{"class":101}," class",[33,748,749],{"class":112}," LogEntry",[33,751,284],{"class":124},[33,753,754],{"class":105},"ts",[33,756,290],{"class":124},[33,758,759],{"class":112},"Long",[33,761,194],{"class":124},[33,763,764],{"class":105},"level",[33,766,290],{"class":124},[33,768,197],{"class":112},[33,770,194],{"class":124},[33,772,773],{"class":105},"msg",[33,775,290],{"class":124},[33,777,197],{"class":112},[33,779,780],{"class":124},")\n",[33,782,783],{"class":35,"line":61},[33,784,95],{"emptyLinePlaceholder":94},[33,786,787,790,793],{"class":35,"line":67},[33,788,789],{"class":101},"object",[33,791,792],{"class":112}," LogPipeline",[33,794,263],{"class":101},[33,796,797],{"class":35,"line":73},[33,798,799],{"class":39},"  \u002F\u002F Function composition with andThen \u002F compose — builds a single pipeline\n",[33,801,802,804,807,809,811,813],{"class":35,"line":79},[33,803,269],{"class":101},[33,805,806],{"class":112}," LogFilter",[33,808,121],{"class":101},[33,810,749],{"class":112},[33,812,116],{"class":101},[33,814,815],{"class":112}," Boolean\n",[33,817,818,820,823,825,827,829],{"class":35,"line":85},[33,819,269],{"class":101},[33,821,822],{"class":112}," LogTransform",[33,824,121],{"class":101},[33,826,749],{"class":112},[33,828,116],{"class":101},[33,830,831],{"class":112}," LogEntry\n",[33,833,834],{"class":35,"line":91},[33,835,95],{"emptyLinePlaceholder":94},[33,837,838,841,844,846,848,850,853,856],{"class":35,"line":98},[33,839,840],{"class":101},"  val",[33,842,843],{"class":105}," errorFilter",[33,845,109],{"class":101},[33,847,806],{"class":112},[33,849,121],{"class":101},[33,851,852],{"class":124}," _.level ",[33,854,855],{"class":101},"==",[33,857,859],{"class":858},"sJ6F3"," \"ERROR\"\n",[33,861,862,864,867,869,871,873,876,878,881,883,886,889,892,895],{"class":35,"line":143},[33,863,840],{"class":101},[33,865,866],{"class":105}," enrich",[33,868,109],{"class":101},[33,870,822],{"class":112},[33,872,121],{"class":101},[33,874,875],{"class":124}," e ",[33,877,128],{"class":101},[33,879,880],{"class":124}," e.copy(msg ",[33,882,355],{"class":101},[33,884,885],{"class":101}," s",[33,887,888],{"class":858},"\"[svc] ",[33,890,891],{"class":124},"${e.msg}",[33,893,894],{"class":858},"\"",[33,896,780],{"class":124},[33,898,899],{"class":35,"line":152},[33,900,95],{"emptyLinePlaceholder":94},[33,902,903],{"class":35,"line":161},[33,904,905],{"class":39},"  \u002F\u002F andThen: (f andThen g)(x) = g(f(x)) — left-to-right reading\n",[33,907,908],{"class":35,"line":166},[33,909,910],{"class":39},"  \u002F\u002F compose: (f compose g)(x) = f(g(x)) — right-to-left\n",[33,912,913,915,918,920,922,924],{"class":35,"line":172},[33,914,840],{"class":101},[33,916,917],{"class":105}," pipeline",[33,919,109],{"class":101},[33,921,806],{"class":112},[33,923,121],{"class":101},[33,925,926],{"class":124}," errorFilter\n",[33,928,929,931,933,935,937,939],{"class":35,"line":178},[33,930,840],{"class":101},[33,932,582],{"class":105},[33,934,109],{"class":101},[33,936,822],{"class":112},[33,938,121],{"class":101},[33,940,941],{"class":124}," enrich\n",[33,943,944],{"class":35,"line":243},[33,945,95],{"emptyLinePlaceholder":94},[33,947,948,950,952,954,957,959,961,963,966,968,970,972,974,976,978],{"class":35,"line":248},[33,949,278],{"class":101},[33,951,319],{"class":112},[33,953,284],{"class":124},[33,955,956],{"class":105},"entries",[33,958,290],{"class":124},[33,960,541],{"class":112},[33,962,304],{"class":124},[33,964,965],{"class":112},"LogEntry",[33,967,548],{"class":124},[33,969,109],{"class":101},[33,971,553],{"class":112},[33,973,304],{"class":124},[33,975,197],{"class":112},[33,977,352],{"class":124},[33,979,562],{"class":101},[33,981,982],{"class":35,"line":254},[33,983,984],{"class":124},"    entries\n",[33,986,987,990],{"class":35,"line":266},[33,988,989],{"class":124},"      .filter(pipeline)                    ",[33,991,992],{"class":39},"\u002F\u002F LogFilter: LogEntry => Boolean\n",[33,994,995,998],{"class":35,"line":275},[33,996,997],{"class":124},"      .map(transform)                      ",[33,999,1000],{"class":39},"\u002F\u002F LogTransform: LogEntry => LogEntry\n",[33,1002,1003,1006],{"class":35,"line":313},[33,1004,1005],{"class":124},"      .map(_.msg)                          ",[33,1007,1008],{"class":39},"\u002F\u002F extract message\n",[33,1010,1011,1014,1017,1020,1023,1026,1029,1031,1034,1037],{"class":35,"line":658},[33,1012,1013],{"class":124},"      .scanLeft(",[33,1015,1016],{"class":858},"\"\"",[33,1018,1019],{"class":124},")(_ ",[33,1021,1022],{"class":101},"+",[33,1024,1025],{"class":858}," \"",[33,1027,1028],{"class":136},"\\n",[33,1030,894],{"class":858},[33,1032,1033],{"class":101}," +",[33,1035,1036],{"class":124}," _)          ",[33,1038,1039],{"class":39},"\u002F\u002F accumulate with prefix\n",[33,1041,1042,1045,1048,1051],{"class":35,"line":667},[33,1043,1044],{"class":124},"      .drop(",[33,1046,1047],{"class":136},"1",[33,1049,1050],{"class":124},")                             ",[33,1052,1053],{"class":39},"\u002F\u002F remove initial \"\"\n",[33,1055,1057],{"class":35,"line":1056},26,[33,1058,95],{"emptyLinePlaceholder":94},[33,1060,1062],{"class":35,"line":1061},27,[33,1063,1064],{"class":39},"  \u002F\u002F Partial application for reusable, configurable components\n",[33,1066,1068,1070,1073,1075,1077,1079,1081,1083,1085,1087,1089,1091,1093],{"class":35,"line":1067},28,[33,1069,278],{"class":101},[33,1071,1072],{"class":112}," filterByLevel",[33,1074,284],{"class":124},[33,1076,764],{"class":105},[33,1078,290],{"class":124},[33,1080,197],{"class":112},[33,1082,296],{"class":124},[33,1084,109],{"class":101},[33,1086,806],{"class":112},[33,1088,121],{"class":101},[33,1090,852],{"class":124},[33,1092,855],{"class":101},[33,1094,1095],{"class":124}," level\n",[33,1097,1099,1101,1104,1106,1109,1112,1115],{"class":35,"line":1098},29,[33,1100,840],{"class":101},[33,1102,1103],{"class":105}," warnFilter",[33,1105,121],{"class":101},[33,1107,1108],{"class":124}," filterByLevel(",[33,1110,1111],{"class":858},"\"WARN\"",[33,1113,1114],{"class":124},")   ",[33,1116,1117],{"class":39},"\u002F\u002F partial application → reusable filter\n",[15,1119,1121],{"id":1120},"currying-multiple-parameter-lists","Currying & Multiple Parameter Lists",[20,1123,1124],{"language":22},[24,1125,1127],{"className":26,"code":1126,"language":22,"meta":28,"style":28},"\u002F\u002F Multiple parameter lists enable:\n\u002F\u002F   1. Type inference boundary — first list informs second list's types\n\u002F\u002F   2. Trailing block syntax for DSL-style\n\u002F\u002F   3. Partial application without placeholder syntax\n\n\u002F\u002F Type inference: first param list determines type parameter for second\ndef mapExactly[A, B](list: List[A])(f: A => B): List[B] = list.map(f)\nmapExactly(List(1, 2, 3))(x => x * 2)      \u002F\u002F A=Int inferred from first list; f: Int=>B, no annotation needed\n\u002F\u002F With single list: mapExactly(List(1,2,3), x => x * 2) — type of x unknown, must annotate\n\n\u002F\u002F DSL-style trailing block:\ndef withResource[R](acquire: => R)(release: R => Unit)(body: R => Unit): Unit =\n  val r = acquire\n  try body(r) finally release(r)\n\nwithResource(openSocket())(_.close()) { socket =>\n  socket.write(\"data\")                     \u002F\u002F reads as: \"with resource [acquired] [released] do { body }\"\n}\n\n\u002F\u002F Curry for dependency injection — first list: config, second list: payload\ndef httpRequest(config: ClientConfig)(url: String, body: Array[Byte]): Response =\n  ???\nval apiCall = httpRequest(prodConfig)      \u002F\u002F partially applied — reusable with different URLs\napiCall(\"\u002Fusers\", payload)\n",[30,1128,1129,1134,1139,1144,1149,1153,1158,1221,1259,1264,1268,1273,1332,1344,1358,1362,1370,1384,1389,1393,1398,1446,1451,1466],{"__ignoreMap":28},[33,1130,1131],{"class":35,"line":36},[33,1132,1133],{"class":39},"\u002F\u002F Multiple parameter lists enable:\n",[33,1135,1136],{"class":35,"line":43},[33,1137,1138],{"class":39},"\u002F\u002F   1. Type inference boundary — first list informs second list's types\n",[33,1140,1141],{"class":35,"line":49},[33,1142,1143],{"class":39},"\u002F\u002F   2. Trailing block syntax for DSL-style\n",[33,1145,1146],{"class":35,"line":55},[33,1147,1148],{"class":39},"\u002F\u002F   3. Partial application without placeholder syntax\n",[33,1150,1151],{"class":35,"line":61},[33,1152,95],{"emptyLinePlaceholder":94},[33,1154,1155],{"class":35,"line":67},[33,1156,1157],{"class":39},"\u002F\u002F Type inference: first param list determines type parameter for second\n",[33,1159,1160,1162,1165,1167,1170,1172,1175,1178,1181,1183,1185,1187,1189,1192,1195,1197,1199,1201,1204,1206,1208,1210,1212,1214,1216,1218],{"class":35,"line":73},[33,1161,316],{"class":101},[33,1163,1164],{"class":112}," mapExactly",[33,1166,304],{"class":124},[33,1168,1169],{"class":112},"A",[33,1171,194],{"class":124},[33,1173,1174],{"class":112},"B",[33,1176,1177],{"class":124},"](",[33,1179,1180],{"class":105},"list",[33,1182,290],{"class":124},[33,1184,541],{"class":112},[33,1186,304],{"class":124},[33,1188,1169],{"class":112},[33,1190,1191],{"class":124},"])(",[33,1193,1194],{"class":105},"f",[33,1196,290],{"class":124},[33,1198,1169],{"class":112},[33,1200,116],{"class":101},[33,1202,1203],{"class":112}," B",[33,1205,296],{"class":124},[33,1207,109],{"class":101},[33,1209,553],{"class":112},[33,1211,304],{"class":124},[33,1213,1174],{"class":112},[33,1215,352],{"class":124},[33,1217,355],{"class":101},[33,1219,1220],{"class":124}," list.map(f)\n",[33,1222,1223,1226,1228,1230,1232,1234,1237,1239,1242,1245,1247,1249,1251,1253,1256],{"class":35,"line":79},[33,1224,1225],{"class":124},"mapExactly(",[33,1227,541],{"class":112},[33,1229,284],{"class":124},[33,1231,1047],{"class":136},[33,1233,194],{"class":124},[33,1235,1236],{"class":136},"2",[33,1238,194],{"class":124},[33,1240,1241],{"class":136},"3",[33,1243,1244],{"class":124},"))(x ",[33,1246,128],{"class":101},[33,1248,125],{"class":124},[33,1250,133],{"class":101},[33,1252,137],{"class":136},[33,1254,1255],{"class":124},")      ",[33,1257,1258],{"class":39},"\u002F\u002F A=Int inferred from first list; f: Int=>B, no annotation needed\n",[33,1260,1261],{"class":35,"line":85},[33,1262,1263],{"class":39},"\u002F\u002F With single list: mapExactly(List(1,2,3), x => x * 2) — type of x unknown, must annotate\n",[33,1265,1266],{"class":35,"line":91},[33,1267,95],{"emptyLinePlaceholder":94},[33,1269,1270],{"class":35,"line":98},[33,1271,1272],{"class":39},"\u002F\u002F DSL-style trailing block:\n",[33,1274,1275,1277,1280,1282,1285,1287,1290,1292,1294,1297,1299,1302,1304,1306,1308,1311,1313,1316,1318,1320,1322,1324,1326,1328,1330],{"class":35,"line":143},[33,1276,316],{"class":101},[33,1278,1279],{"class":112}," withResource",[33,1281,304],{"class":124},[33,1283,1284],{"class":112},"R",[33,1286,1177],{"class":124},[33,1288,1289],{"class":105},"acquire",[33,1291,290],{"class":124},[33,1293,128],{"class":101},[33,1295,1296],{"class":112}," R",[33,1298,332],{"class":124},[33,1300,1301],{"class":105},"release",[33,1303,290],{"class":124},[33,1305,1284],{"class":112},[33,1307,116],{"class":101},[33,1309,1310],{"class":112}," Unit",[33,1312,332],{"class":124},[33,1314,1315],{"class":105},"body",[33,1317,290],{"class":124},[33,1319,1284],{"class":112},[33,1321,116],{"class":101},[33,1323,1310],{"class":112},[33,1325,296],{"class":124},[33,1327,109],{"class":101},[33,1329,1310],{"class":112},[33,1331,421],{"class":101},[33,1333,1334,1336,1339,1341],{"class":35,"line":152},[33,1335,840],{"class":101},[33,1337,1338],{"class":105}," r",[33,1340,121],{"class":101},[33,1342,1343],{"class":124}," acquire\n",[33,1345,1346,1349,1352,1355],{"class":35,"line":161},[33,1347,1348],{"class":101},"  try",[33,1350,1351],{"class":124}," body(r) ",[33,1353,1354],{"class":101},"finally",[33,1356,1357],{"class":124}," release(r)\n",[33,1359,1360],{"class":35,"line":166},[33,1361,95],{"emptyLinePlaceholder":94},[33,1363,1364,1367],{"class":35,"line":172},[33,1365,1366],{"class":124},"withResource(openSocket())(_.close()) { socket ",[33,1368,1369],{"class":101},"=>\n",[33,1371,1372,1375,1378,1381],{"class":35,"line":178},[33,1373,1374],{"class":124},"  socket.write(",[33,1376,1377],{"class":858},"\"data\"",[33,1379,1380],{"class":124},")                     ",[33,1382,1383],{"class":39},"\u002F\u002F reads as: \"with resource [acquired] [released] do { body }\"\n",[33,1385,1386],{"class":35,"line":243},[33,1387,1388],{"class":124},"}\n",[33,1390,1391],{"class":35,"line":248},[33,1392,95],{"emptyLinePlaceholder":94},[33,1394,1395],{"class":35,"line":254},[33,1396,1397],{"class":39},"\u002F\u002F Curry for dependency injection — first list: config, second list: payload\n",[33,1399,1400,1402,1405,1407,1410,1412,1415,1417,1420,1422,1424,1426,1428,1430,1433,1435,1437,1439,1441,1444],{"class":35,"line":266},[33,1401,316],{"class":101},[33,1403,1404],{"class":112}," httpRequest",[33,1406,284],{"class":124},[33,1408,1409],{"class":105},"config",[33,1411,290],{"class":124},[33,1413,1414],{"class":112},"ClientConfig",[33,1416,332],{"class":124},[33,1418,1419],{"class":105},"url",[33,1421,290],{"class":124},[33,1423,197],{"class":112},[33,1425,194],{"class":124},[33,1427,1315],{"class":105},[33,1429,290],{"class":124},[33,1431,1432],{"class":112},"Array",[33,1434,304],{"class":124},[33,1436,307],{"class":112},[33,1438,548],{"class":124},[33,1440,109],{"class":101},[33,1442,1443],{"class":112}," Response",[33,1445,421],{"class":101},[33,1447,1448],{"class":35,"line":275},[33,1449,1450],{"class":101},"  ???\n",[33,1452,1453,1455,1458,1460,1463],{"class":35,"line":313},[33,1454,102],{"class":101},[33,1456,1457],{"class":105}," apiCall",[33,1459,121],{"class":101},[33,1461,1462],{"class":124}," httpRequest(prodConfig)      ",[33,1464,1465],{"class":39},"\u002F\u002F partially applied — reusable with different URLs\n",[33,1467,1468,1471,1474],{"class":35,"line":658},[33,1469,1470],{"class":124},"apiCall(",[33,1472,1473],{"class":858},"\"\u002Fusers\"",[33,1475,1476],{"class":124},", payload)\n",[15,1478,1480,1481,1484,1485,1487,1488,296],{"id":1479},"by-name-parameters-t-vs-by-need-t-with-lazy","By-Name Parameters (",[30,1482,1483],{},"=> T",") vs By-Need (",[30,1486,1483],{}," with ",[30,1489,1490],{},"lazy",[20,1492,1493],{"language":22},[24,1494,1496],{"className":26,"code":1495,"language":22,"meta":28,"style":28},"\u002F\u002F By-name: the expression is re-evaluated EVERY time it's referenced\ndef trace[A](msg: => String)(value: A): A =\n  println(msg)                             \u002F\u002F eval #1\n  println(msg)                             \u002F\u002F eval #2 — runs the expression AGAIN\n  value\n\ntrace({ println(\"evaluating\"); \"msg\" })(42)\n\u002F\u002F Prints: evaluating, \"msg\", evaluating, \"msg\", returns 42\n\n\u002F\u002F By-need: evaluate once, cache (memoize)\ndef traceOnce[A](msg: => String)(value: A): A =\n  lazy val m = msg                         \u002F\u002F evaluated once, cached\n  println(m)\n  println(m)\n  value\n\ntraceOnce({ println(\"evaluating\"); \"msg\" })(42)\n\u002F\u002F Prints: evaluating, \"msg\", \"msg\", returns 42\n\n\u002F\u002F ❌ ANTI-PATTERN: by-name in a loop — O(n) re-evaluation\ndef retry[T](max: Int)(op: => T): T =\n  var attempt = 0\n  while attempt \u003C max do\n    try return op                          \u002F\u002F op re-evaluated each iteration (correct here)\n    catch case e if attempt \u003C max - 1 => attempt += 1\n  throw new RuntimeException(\"exhausted retries\")\n\n\u002F\u002F ✅ CORRECT for parameter validation: by-name with lazy for expensive defaults\ndef loadConfig(path: => String = defaultPath()): Config =\n  lazy val p = path                        \u002F\u002F evaluate once even if referenced multiple times\n  Using.resource(io.Source.fromFile(p)) { _.mkString }\n",[30,1497,1498,1503,1543,1551,1558,1563,1567,1589,1594,1598,1603,1640,1659,1664,1668,1672,1676,1693,1698,1702,1707,1748,1760,1777,1791,1823,1841,1845,1850,1880,1898],{"__ignoreMap":28},[33,1499,1500],{"class":35,"line":36},[33,1501,1502],{"class":39},"\u002F\u002F By-name: the expression is re-evaluated EVERY time it's referenced\n",[33,1504,1505,1507,1510,1512,1514,1516,1518,1520,1522,1525,1527,1530,1532,1534,1536,1538,1541],{"class":35,"line":43},[33,1506,316],{"class":101},[33,1508,1509],{"class":112}," trace",[33,1511,304],{"class":124},[33,1513,1169],{"class":112},[33,1515,1177],{"class":124},[33,1517,773],{"class":105},[33,1519,290],{"class":124},[33,1521,128],{"class":101},[33,1523,1524],{"class":112}," String",[33,1526,332],{"class":124},[33,1528,1529],{"class":105},"value",[33,1531,290],{"class":124},[33,1533,1169],{"class":112},[33,1535,296],{"class":124},[33,1537,109],{"class":101},[33,1539,1540],{"class":112}," A",[33,1542,421],{"class":101},[33,1544,1545,1548],{"class":35,"line":49},[33,1546,1547],{"class":124},"  println(msg)                             ",[33,1549,1550],{"class":39},"\u002F\u002F eval #1\n",[33,1552,1553,1555],{"class":35,"line":55},[33,1554,1547],{"class":124},[33,1556,1557],{"class":39},"\u002F\u002F eval #2 — runs the expression AGAIN\n",[33,1559,1560],{"class":35,"line":61},[33,1561,1562],{"class":124},"  value\n",[33,1564,1565],{"class":35,"line":67},[33,1566,95],{"emptyLinePlaceholder":94},[33,1568,1569,1572,1575,1578,1581,1584,1587],{"class":35,"line":73},[33,1570,1571],{"class":124},"trace({ println(",[33,1573,1574],{"class":858},"\"evaluating\"",[33,1576,1577],{"class":124},"); ",[33,1579,1580],{"class":858},"\"msg\"",[33,1582,1583],{"class":124}," })(",[33,1585,1586],{"class":136},"42",[33,1588,780],{"class":124},[33,1590,1591],{"class":35,"line":79},[33,1592,1593],{"class":39},"\u002F\u002F Prints: evaluating, \"msg\", evaluating, \"msg\", returns 42\n",[33,1595,1596],{"class":35,"line":85},[33,1597,95],{"emptyLinePlaceholder":94},[33,1599,1600],{"class":35,"line":91},[33,1601,1602],{"class":39},"\u002F\u002F By-need: evaluate once, cache (memoize)\n",[33,1604,1605,1607,1610,1612,1614,1616,1618,1620,1622,1624,1626,1628,1630,1632,1634,1636,1638],{"class":35,"line":98},[33,1606,316],{"class":101},[33,1608,1609],{"class":112}," traceOnce",[33,1611,304],{"class":124},[33,1613,1169],{"class":112},[33,1615,1177],{"class":124},[33,1617,773],{"class":105},[33,1619,290],{"class":124},[33,1621,128],{"class":101},[33,1623,1524],{"class":112},[33,1625,332],{"class":124},[33,1627,1529],{"class":105},[33,1629,290],{"class":124},[33,1631,1169],{"class":112},[33,1633,296],{"class":124},[33,1635,109],{"class":101},[33,1637,1540],{"class":112},[33,1639,421],{"class":101},[33,1641,1642,1645,1648,1651,1653,1656],{"class":35,"line":143},[33,1643,1644],{"class":101},"  lazy",[33,1646,1647],{"class":101}," val",[33,1649,1650],{"class":105}," m",[33,1652,121],{"class":101},[33,1654,1655],{"class":124}," msg                         ",[33,1657,1658],{"class":39},"\u002F\u002F evaluated once, cached\n",[33,1660,1661],{"class":35,"line":152},[33,1662,1663],{"class":124},"  println(m)\n",[33,1665,1666],{"class":35,"line":161},[33,1667,1663],{"class":124},[33,1669,1670],{"class":35,"line":166},[33,1671,1562],{"class":124},[33,1673,1674],{"class":35,"line":172},[33,1675,95],{"emptyLinePlaceholder":94},[33,1677,1678,1681,1683,1685,1687,1689,1691],{"class":35,"line":178},[33,1679,1680],{"class":124},"traceOnce({ println(",[33,1682,1574],{"class":858},[33,1684,1577],{"class":124},[33,1686,1580],{"class":858},[33,1688,1583],{"class":124},[33,1690,1586],{"class":136},[33,1692,780],{"class":124},[33,1694,1695],{"class":35,"line":243},[33,1696,1697],{"class":39},"\u002F\u002F Prints: evaluating, \"msg\", \"msg\", returns 42\n",[33,1699,1700],{"class":35,"line":248},[33,1701,95],{"emptyLinePlaceholder":94},[33,1703,1704],{"class":35,"line":254},[33,1705,1706],{"class":39},"\u002F\u002F ❌ ANTI-PATTERN: by-name in a loop — O(n) re-evaluation\n",[33,1708,1709,1711,1714,1716,1719,1721,1724,1726,1728,1730,1733,1735,1737,1740,1742,1744,1746],{"class":35,"line":266},[33,1710,316],{"class":101},[33,1712,1713],{"class":112}," retry",[33,1715,304],{"class":124},[33,1717,1718],{"class":112},"T",[33,1720,1177],{"class":124},[33,1722,1723],{"class":105},"max",[33,1725,290],{"class":124},[33,1727,191],{"class":112},[33,1729,332],{"class":124},[33,1731,1732],{"class":105},"op",[33,1734,290],{"class":124},[33,1736,128],{"class":101},[33,1738,1739],{"class":112}," T",[33,1741,296],{"class":124},[33,1743,109],{"class":101},[33,1745,1739],{"class":112},[33,1747,421],{"class":101},[33,1749,1750,1752,1755,1757],{"class":35,"line":275},[33,1751,426],{"class":101},[33,1753,1754],{"class":105}," attempt",[33,1756,121],{"class":101},[33,1758,1759],{"class":136}," 0\n",[33,1761,1762,1765,1768,1771,1774],{"class":35,"line":313},[33,1763,1764],{"class":101},"  while",[33,1766,1767],{"class":124}," attempt ",[33,1769,1770],{"class":101},"\u003C",[33,1772,1773],{"class":124}," max ",[33,1775,1776],{"class":101},"do\n",[33,1778,1779,1782,1785,1788],{"class":35,"line":658},[33,1780,1781],{"class":101},"    try",[33,1783,1784],{"class":101}," return",[33,1786,1787],{"class":124}," op                          ",[33,1789,1790],{"class":39},"\u002F\u002F op re-evaluated each iteration (correct here)\n",[33,1792,1793,1796,1798,1800,1803,1805,1807,1809,1812,1814,1816,1818,1820],{"class":35,"line":667},[33,1794,1795],{"class":101},"    catch",[33,1797,743],{"class":101},[33,1799,875],{"class":124},[33,1801,1802],{"class":101},"if",[33,1804,1767],{"class":124},[33,1806,1770],{"class":101},[33,1808,1773],{"class":124},[33,1810,1811],{"class":101},"-",[33,1813,458],{"class":136},[33,1815,116],{"class":101},[33,1817,1767],{"class":124},[33,1819,455],{"class":101},[33,1821,1822],{"class":136}," 1\n",[33,1824,1825,1828,1831,1834,1836,1839],{"class":35,"line":1056},[33,1826,1827],{"class":101},"  throw",[33,1829,1830],{"class":101}," new",[33,1832,1833],{"class":112}," RuntimeException",[33,1835,284],{"class":124},[33,1837,1838],{"class":858},"\"exhausted retries\"",[33,1840,780],{"class":124},[33,1842,1843],{"class":35,"line":1061},[33,1844,95],{"emptyLinePlaceholder":94},[33,1846,1847],{"class":35,"line":1067},[33,1848,1849],{"class":39},"\u002F\u002F ✅ CORRECT for parameter validation: by-name with lazy for expensive defaults\n",[33,1851,1852,1854,1857,1859,1862,1864,1866,1868,1870,1873,1875,1878],{"class":35,"line":1098},[33,1853,316],{"class":101},[33,1855,1856],{"class":112}," loadConfig",[33,1858,284],{"class":124},[33,1860,1861],{"class":105},"path",[33,1863,290],{"class":124},[33,1865,128],{"class":101},[33,1867,1524],{"class":112},[33,1869,121],{"class":101},[33,1871,1872],{"class":124}," defaultPath())",[33,1874,109],{"class":101},[33,1876,1877],{"class":112}," Config",[33,1879,421],{"class":101},[33,1881,1883,1885,1887,1890,1892,1895],{"class":35,"line":1882},30,[33,1884,1644],{"class":101},[33,1886,1647],{"class":101},[33,1888,1889],{"class":105}," p",[33,1891,121],{"class":101},[33,1893,1894],{"class":124}," path                        ",[33,1896,1897],{"class":39},"\u002F\u002F evaluate once even if referenced multiple times\n",[33,1899,1901,1904,1907,1910],{"class":35,"line":1900},31,[33,1902,1903],{"class":112},"  Using",[33,1905,1906],{"class":124},".resource(io.",[33,1908,1909],{"class":112},"Source",[33,1911,1912],{"class":124},".fromFile(p)) { _.mkString }\n",[15,1914,1916,1917,1920],{"id":1915},"tail-recursion-tailrec-loop-desugaring","Tail Recursion — ",[30,1918,1919],{},"@tailrec"," & Loop Desugaring",[20,1922,1923],{"language":22},[24,1924,1926],{"className":26,"code":1925,"language":22,"meta":28,"style":28},"import scala.annotation.tailrec\n\n\u002F\u002F @tailrec: compiler verifies the recursive call is in tail position.\n\u002F\u002F If NOT tail-recursive → COMPILE ERROR (not a warning).\n\u002F\u002F Tail calls are rewritten to a while loop → no stack frame growth, O(1) stack.\n\n@tailrec\ndef sumTo(n: Int, acc: Long = 0): Long =\n  if n \u003C= 0 then acc else sumTo(n - 1, acc + n)  \u002F\u002F tail call → rewritten to loop\n\n\u002F\u002F ❌ NOT tail-recursive — the multiplication happens AFTER the recursive call returns\ndef factorial(n: Int): Long =\n  if n \u003C= 1 then 1 else n * factorial(n - 1)     \u002F\u002F n * (result of recursion) — NOT tail position\n\u002F\u002F @tailrec on this → COMPILE ERROR: \"not in tail position\"\n\n\u002F\u002F ✅ Tail-recursive factorial with accumulator\n@tailrec\ndef factorial(n: Int, acc: Long = 1): Long =\n  if n \u003C= 1 then acc else factorial(n - 1, acc * n)\n\n\u002F\u002F Mutually recursive: @tailrec does NOT work across functions\n\u002F\u002F → Use a loop with a state machine, or trampoline (TailRec from Cats)\ndef trampoline[T](f: () => Either[() => T, T]): T =\n  @tailrec\n  def loop(current: () => Either[() => T, T]): T =\n    current() match\n      case Left(next) => loop(next)        \u002F\u002F tail call within loop — OK\n      case Right(result) => result\n  loop(f)\n",[30,1927,1928,1944,1948,1953,1958,1963,1967,1974,2013,2052,2056,2061,2084,2118,2123,2127,2132,2138,2172,2201,2205,2210,2215,2257,2264,2300,2308,2327,2342],{"__ignoreMap":28},[33,1929,1930,1932,1934,1936,1939,1941],{"class":35,"line":36},[33,1931,717],{"class":101},[33,1933,720],{"class":112},[33,1935,723],{"class":124},[33,1937,1938],{"class":112},"annotation",[33,1940,723],{"class":124},[33,1942,1943],{"class":112},"tailrec\n",[33,1945,1946],{"class":35,"line":43},[33,1947,95],{"emptyLinePlaceholder":94},[33,1949,1950],{"class":35,"line":49},[33,1951,1952],{"class":39},"\u002F\u002F @tailrec: compiler verifies the recursive call is in tail position.\n",[33,1954,1955],{"class":35,"line":55},[33,1956,1957],{"class":39},"\u002F\u002F If NOT tail-recursive → COMPILE ERROR (not a warning).\n",[33,1959,1960],{"class":35,"line":61},[33,1961,1962],{"class":39},"\u002F\u002F Tail calls are rewritten to a while loop → no stack frame growth, O(1) stack.\n",[33,1964,1965],{"class":35,"line":67},[33,1966,95],{"emptyLinePlaceholder":94},[33,1968,1969,1972],{"class":35,"line":73},[33,1970,1971],{"class":101},"@",[33,1973,1943],{"class":124},[33,1975,1976,1978,1981,1983,1986,1988,1990,1992,1995,1997,1999,2001,2004,2006,2008,2011],{"class":35,"line":79},[33,1977,316],{"class":101},[33,1979,1980],{"class":112}," sumTo",[33,1982,284],{"class":124},[33,1984,1985],{"class":105},"n",[33,1987,290],{"class":124},[33,1989,191],{"class":112},[33,1991,194],{"class":124},[33,1993,1994],{"class":105},"acc",[33,1996,290],{"class":124},[33,1998,759],{"class":112},[33,2000,121],{"class":101},[33,2002,2003],{"class":136}," 0",[33,2005,296],{"class":124},[33,2007,109],{"class":101},[33,2009,2010],{"class":112}," Long",[33,2012,421],{"class":101},[33,2014,2015,2018,2021,2024,2026,2029,2032,2034,2037,2039,2041,2044,2046,2049],{"class":35,"line":85},[33,2016,2017],{"class":101},"  if",[33,2019,2020],{"class":124}," n ",[33,2022,2023],{"class":101},"\u003C=",[33,2025,2003],{"class":136},[33,2027,2028],{"class":101}," then",[33,2030,2031],{"class":124}," acc ",[33,2033,237],{"class":101},[33,2035,2036],{"class":124}," sumTo(n ",[33,2038,1811],{"class":101},[33,2040,458],{"class":136},[33,2042,2043],{"class":124},", acc ",[33,2045,1022],{"class":101},[33,2047,2048],{"class":124}," n)  ",[33,2050,2051],{"class":39},"\u002F\u002F tail call → rewritten to loop\n",[33,2053,2054],{"class":35,"line":91},[33,2055,95],{"emptyLinePlaceholder":94},[33,2057,2058],{"class":35,"line":98},[33,2059,2060],{"class":39},"\u002F\u002F ❌ NOT tail-recursive — the multiplication happens AFTER the recursive call returns\n",[33,2062,2063,2065,2068,2070,2072,2074,2076,2078,2080,2082],{"class":35,"line":143},[33,2064,316],{"class":101},[33,2066,2067],{"class":112}," factorial",[33,2069,284],{"class":124},[33,2071,1985],{"class":105},[33,2073,290],{"class":124},[33,2075,191],{"class":112},[33,2077,296],{"class":124},[33,2079,109],{"class":101},[33,2081,2010],{"class":112},[33,2083,421],{"class":101},[33,2085,2086,2088,2090,2092,2094,2096,2098,2101,2103,2105,2108,2110,2112,2115],{"class":35,"line":152},[33,2087,2017],{"class":101},[33,2089,2020],{"class":124},[33,2091,2023],{"class":101},[33,2093,458],{"class":136},[33,2095,2028],{"class":101},[33,2097,458],{"class":136},[33,2099,2100],{"class":101}," else",[33,2102,2020],{"class":124},[33,2104,133],{"class":101},[33,2106,2107],{"class":124}," factorial(n ",[33,2109,1811],{"class":101},[33,2111,458],{"class":136},[33,2113,2114],{"class":124},")     ",[33,2116,2117],{"class":39},"\u002F\u002F n * (result of recursion) — NOT tail position\n",[33,2119,2120],{"class":35,"line":161},[33,2121,2122],{"class":39},"\u002F\u002F @tailrec on this → COMPILE ERROR: \"not in tail position\"\n",[33,2124,2125],{"class":35,"line":166},[33,2126,95],{"emptyLinePlaceholder":94},[33,2128,2129],{"class":35,"line":172},[33,2130,2131],{"class":39},"\u002F\u002F ✅ Tail-recursive factorial with accumulator\n",[33,2133,2134,2136],{"class":35,"line":178},[33,2135,1971],{"class":101},[33,2137,1943],{"class":124},[33,2139,2140,2142,2144,2146,2148,2150,2152,2154,2156,2158,2160,2162,2164,2166,2168,2170],{"class":35,"line":243},[33,2141,316],{"class":101},[33,2143,2067],{"class":112},[33,2145,284],{"class":124},[33,2147,1985],{"class":105},[33,2149,290],{"class":124},[33,2151,191],{"class":112},[33,2153,194],{"class":124},[33,2155,1994],{"class":105},[33,2157,290],{"class":124},[33,2159,759],{"class":112},[33,2161,121],{"class":101},[33,2163,458],{"class":136},[33,2165,296],{"class":124},[33,2167,109],{"class":101},[33,2169,2010],{"class":112},[33,2171,421],{"class":101},[33,2173,2174,2176,2178,2180,2182,2184,2186,2188,2190,2192,2194,2196,2198],{"class":35,"line":248},[33,2175,2017],{"class":101},[33,2177,2020],{"class":124},[33,2179,2023],{"class":101},[33,2181,458],{"class":136},[33,2183,2028],{"class":101},[33,2185,2031],{"class":124},[33,2187,237],{"class":101},[33,2189,2107],{"class":124},[33,2191,1811],{"class":101},[33,2193,458],{"class":136},[33,2195,2043],{"class":124},[33,2197,133],{"class":101},[33,2199,2200],{"class":124}," n)\n",[33,2202,2203],{"class":35,"line":254},[33,2204,95],{"emptyLinePlaceholder":94},[33,2206,2207],{"class":35,"line":266},[33,2208,2209],{"class":39},"\u002F\u002F Mutually recursive: @tailrec does NOT work across functions\n",[33,2211,2212],{"class":35,"line":275},[33,2213,2214],{"class":39},"\u002F\u002F → Use a loop with a state machine, or trampoline (TailRec from Cats)\n",[33,2216,2217,2219,2222,2224,2226,2228,2230,2233,2235,2238,2241,2243,2245,2247,2249,2251,2253,2255],{"class":35,"line":313},[33,2218,316],{"class":101},[33,2220,2221],{"class":112}," trampoline",[33,2223,304],{"class":124},[33,2225,1718],{"class":112},[33,2227,1177],{"class":124},[33,2229,1194],{"class":105},[33,2231,2232],{"class":124},": () ",[33,2234,128],{"class":101},[33,2236,2237],{"class":112}," Either",[33,2239,2240],{"class":124},"[() ",[33,2242,128],{"class":101},[33,2244,1739],{"class":112},[33,2246,194],{"class":124},[33,2248,1718],{"class":112},[33,2250,548],{"class":124},[33,2252,109],{"class":101},[33,2254,1739],{"class":112},[33,2256,421],{"class":101},[33,2258,2259,2262],{"class":35,"line":658},[33,2260,2261],{"class":101},"  @",[33,2263,1943],{"class":124},[33,2265,2266,2268,2271,2273,2276,2278,2280,2282,2284,2286,2288,2290,2292,2294,2296,2298],{"class":35,"line":667},[33,2267,278],{"class":101},[33,2269,2270],{"class":112}," loop",[33,2272,284],{"class":124},[33,2274,2275],{"class":105},"current",[33,2277,2232],{"class":124},[33,2279,128],{"class":101},[33,2281,2237],{"class":112},[33,2283,2240],{"class":124},[33,2285,128],{"class":101},[33,2287,1739],{"class":112},[33,2289,194],{"class":124},[33,2291,1718],{"class":112},[33,2293,548],{"class":124},[33,2295,109],{"class":101},[33,2297,1739],{"class":112},[33,2299,421],{"class":101},[33,2301,2302,2305],{"class":35,"line":1056},[33,2303,2304],{"class":124},"    current() ",[33,2306,2307],{"class":101},"match\n",[33,2309,2310,2313,2316,2319,2321,2324],{"class":35,"line":1061},[33,2311,2312],{"class":101},"      case",[33,2314,2315],{"class":112}," Left",[33,2317,2318],{"class":124},"(next) ",[33,2320,128],{"class":101},[33,2322,2323],{"class":124}," loop(next)        ",[33,2325,2326],{"class":39},"\u002F\u002F tail call within loop — OK\n",[33,2328,2329,2331,2334,2337,2339],{"class":35,"line":1067},[33,2330,2312],{"class":101},[33,2332,2333],{"class":112}," Right",[33,2335,2336],{"class":124},"(result) ",[33,2338,128],{"class":101},[33,2340,2341],{"class":124}," result\n",[33,2343,2344],{"class":35,"line":1098},[33,2345,2346],{"class":124},"  loop(f)\n",[15,2348,2350,2351],{"id":2349},"partial-functions-partialfunctiona-b","Partial Functions — ",[30,2352,2353],{},"PartialFunction[A, B]",[20,2355,2356],{"language":22},[24,2357,2359],{"className":26,"code":2358,"language":22,"meta":28,"style":28},"\u002F\u002F PartialFunction: defined only for a subset of inputs.\n\u002F\u002F Has isDefinedAt(x: A): Boolean + apply(x: A): B\n\u002F\u002F Used in collect, actor receive, route definitions.\n\nval parseStatus: PartialFunction[Int, String] =\n  case 200 => \"OK\"\n  case 404 => \"Not Found\"\n  case 500 | 502 | 503 => \"Server Error\"\n\nparseStatus(200)                          \u002F\u002F → \"OK\"\nparseStatus.isDefinedAt(404)              \u002F\u002F → true\nparseStatus.isDefinedAt(418)              \u002F\u002F → false\n\n\u002F\u002F collect = filter + map in one pass (only processes defined elements)\nList(200, 404, 418, 500).collect(parseStatus)  \u002F\u002F → List(\"OK\", \"Not Found\", \"Server Error\")\n\n\u002F\u002F Compose partial functions: orElse (fallback), andThen (chaining)\nval httpOnly: PartialFunction[Int, String] =\n  case c if c \u002F 100 == 4 || c \u002F 100 == 5 => \"HTTP Error\"\nval all = parseStatus.orElse(httpOnly).orElse { case _ => \"Unknown\" }\n\n\u002F\u002F Real-world: Akka\u002FPekko actor receive is a PartialFunction[Any, Unit]\nval receive: PartialFunction[Any, Unit] =\n  case \"ping\" => sender ! \"pong\"\n  case n: Int if n > 0 => process(n)\n  case _ => \u002F\u002F ignore\n",[30,2360,2361,2366,2371,2376,2380,2404,2417,2429,2452,2456,2470,2484,2496,2500,2505,2532,2536,2541,2564,2606,2632,2636,2641,2666,2684,2709],{"__ignoreMap":28},[33,2362,2363],{"class":35,"line":36},[33,2364,2365],{"class":39},"\u002F\u002F PartialFunction: defined only for a subset of inputs.\n",[33,2367,2368],{"class":35,"line":43},[33,2369,2370],{"class":39},"\u002F\u002F Has isDefinedAt(x: A): Boolean + apply(x: A): B\n",[33,2372,2373],{"class":35,"line":49},[33,2374,2375],{"class":39},"\u002F\u002F Used in collect, actor receive, route definitions.\n",[33,2377,2378],{"class":35,"line":55},[33,2379,95],{"emptyLinePlaceholder":94},[33,2381,2382,2384,2387,2389,2392,2394,2396,2398,2400,2402],{"class":35,"line":61},[33,2383,102],{"class":101},[33,2385,2386],{"class":105}," parseStatus",[33,2388,109],{"class":101},[33,2390,2391],{"class":112}," PartialFunction",[33,2393,304],{"class":124},[33,2395,191],{"class":112},[33,2397,194],{"class":124},[33,2399,197],{"class":112},[33,2401,352],{"class":124},[33,2403,562],{"class":101},[33,2405,2406,2409,2412,2414],{"class":35,"line":67},[33,2407,2408],{"class":101},"  case",[33,2410,2411],{"class":136}," 200",[33,2413,116],{"class":101},[33,2415,2416],{"class":858}," \"OK\"\n",[33,2418,2419,2421,2424,2426],{"class":35,"line":73},[33,2420,2408],{"class":101},[33,2422,2423],{"class":136}," 404",[33,2425,116],{"class":101},[33,2427,2428],{"class":858}," \"Not Found\"\n",[33,2430,2431,2433,2436,2439,2442,2444,2447,2449],{"class":35,"line":79},[33,2432,2408],{"class":101},[33,2434,2435],{"class":136}," 500",[33,2437,2438],{"class":101}," |",[33,2440,2441],{"class":136}," 502",[33,2443,2438],{"class":101},[33,2445,2446],{"class":136}," 503",[33,2448,116],{"class":101},[33,2450,2451],{"class":858}," \"Server Error\"\n",[33,2453,2454],{"class":35,"line":85},[33,2455,95],{"emptyLinePlaceholder":94},[33,2457,2458,2461,2464,2467],{"class":35,"line":91},[33,2459,2460],{"class":124},"parseStatus(",[33,2462,2463],{"class":136},"200",[33,2465,2466],{"class":124},")                          ",[33,2468,2469],{"class":39},"\u002F\u002F → \"OK\"\n",[33,2471,2472,2475,2478,2481],{"class":35,"line":98},[33,2473,2474],{"class":124},"parseStatus.isDefinedAt(",[33,2476,2477],{"class":136},"404",[33,2479,2480],{"class":124},")              ",[33,2482,2483],{"class":39},"\u002F\u002F → true\n",[33,2485,2486,2488,2491,2493],{"class":35,"line":143},[33,2487,2474],{"class":124},[33,2489,2490],{"class":136},"418",[33,2492,2480],{"class":124},[33,2494,2495],{"class":39},"\u002F\u002F → false\n",[33,2497,2498],{"class":35,"line":152},[33,2499,95],{"emptyLinePlaceholder":94},[33,2501,2502],{"class":35,"line":161},[33,2503,2504],{"class":39},"\u002F\u002F collect = filter + map in one pass (only processes defined elements)\n",[33,2506,2507,2509,2511,2513,2515,2517,2519,2521,2523,2526,2529],{"class":35,"line":166},[33,2508,541],{"class":112},[33,2510,284],{"class":124},[33,2512,2463],{"class":136},[33,2514,194],{"class":124},[33,2516,2477],{"class":136},[33,2518,194],{"class":124},[33,2520,2490],{"class":136},[33,2522,194],{"class":124},[33,2524,2525],{"class":136},"500",[33,2527,2528],{"class":124},").collect(parseStatus)  ",[33,2530,2531],{"class":39},"\u002F\u002F → List(\"OK\", \"Not Found\", \"Server Error\")\n",[33,2533,2534],{"class":35,"line":172},[33,2535,95],{"emptyLinePlaceholder":94},[33,2537,2538],{"class":35,"line":178},[33,2539,2540],{"class":39},"\u002F\u002F Compose partial functions: orElse (fallback), andThen (chaining)\n",[33,2542,2543,2545,2548,2550,2552,2554,2556,2558,2560,2562],{"class":35,"line":243},[33,2544,102],{"class":101},[33,2546,2547],{"class":105}," httpOnly",[33,2549,109],{"class":101},[33,2551,2391],{"class":112},[33,2553,304],{"class":124},[33,2555,191],{"class":112},[33,2557,194],{"class":124},[33,2559,197],{"class":112},[33,2561,352],{"class":124},[33,2563,562],{"class":101},[33,2565,2566,2568,2571,2573,2575,2578,2581,2584,2587,2590,2592,2594,2596,2598,2601,2603],{"class":35,"line":248},[33,2567,2408],{"class":101},[33,2569,2570],{"class":124}," c ",[33,2572,1802],{"class":101},[33,2574,2570],{"class":124},[33,2576,2577],{"class":101},"\u002F",[33,2579,2580],{"class":136}," 100",[33,2582,2583],{"class":101}," ==",[33,2585,2586],{"class":136}," 4",[33,2588,2589],{"class":101}," ||",[33,2591,2570],{"class":124},[33,2593,2577],{"class":101},[33,2595,2580],{"class":136},[33,2597,2583],{"class":101},[33,2599,2600],{"class":136}," 5",[33,2602,116],{"class":101},[33,2604,2605],{"class":858}," \"HTTP Error\"\n",[33,2607,2608,2610,2613,2615,2618,2621,2624,2626,2629],{"class":35,"line":254},[33,2609,102],{"class":101},[33,2611,2612],{"class":105}," all",[33,2614,121],{"class":101},[33,2616,2617],{"class":124}," parseStatus.orElse(httpOnly).orElse { ",[33,2619,2620],{"class":101},"case",[33,2622,2623],{"class":124}," _ ",[33,2625,128],{"class":101},[33,2627,2628],{"class":858}," \"Unknown\"",[33,2630,2631],{"class":124}," }\n",[33,2633,2634],{"class":35,"line":266},[33,2635,95],{"emptyLinePlaceholder":94},[33,2637,2638],{"class":35,"line":275},[33,2639,2640],{"class":39},"\u002F\u002F Real-world: Akka\u002FPekko actor receive is a PartialFunction[Any, Unit]\n",[33,2642,2643,2645,2648,2650,2652,2654,2657,2659,2662,2664],{"class":35,"line":313},[33,2644,102],{"class":101},[33,2646,2647],{"class":105}," receive",[33,2649,109],{"class":101},[33,2651,2391],{"class":112},[33,2653,304],{"class":124},[33,2655,2656],{"class":112},"Any",[33,2658,194],{"class":124},[33,2660,2661],{"class":112},"Unit",[33,2663,352],{"class":124},[33,2665,562],{"class":101},[33,2667,2668,2670,2673,2675,2678,2681],{"class":35,"line":658},[33,2669,2408],{"class":101},[33,2671,2672],{"class":858}," \"ping\"",[33,2674,116],{"class":101},[33,2676,2677],{"class":124}," sender ",[33,2679,2680],{"class":101},"!",[33,2682,2683],{"class":858}," \"pong\"\n",[33,2685,2686,2688,2691,2693,2695,2697,2699,2702,2704,2706],{"class":35,"line":667},[33,2687,2408],{"class":101},[33,2689,2690],{"class":105}," n",[33,2692,290],{"class":124},[33,2694,191],{"class":112},[33,2696,220],{"class":101},[33,2698,2020],{"class":124},[33,2700,2701],{"class":101},">",[33,2703,2003],{"class":136},[33,2705,116],{"class":101},[33,2707,2708],{"class":124}," process(n)\n",[33,2710,2711,2713,2715,2717],{"class":35,"line":1056},[33,2712,2408],{"class":101},[33,2714,2623],{"class":124},[33,2716,128],{"class":101},[33,2718,2719],{"class":39}," \u002F\u002F ignore\n",[15,2721,2723,2724,2727,2728,2727,2731],{"id":2722},"for-comprehension-desugared-to-flatmap-map-filter","For-Comprehension — Desugared to ",[30,2725,2726],{},"flatMap"," \u002F ",[30,2729,2730],{},"map",[30,2732,2733],{},"filter",[20,2735,2736],{"language":22},[24,2737,2739],{"className":26,"code":2738,"language":22,"meta":28,"style":28},"\u002F\u002F For-comprehension is NOT a loop — it's syntactic sugar for flatMap\u002Fmap\u002FwithFilter\n\u002F\u002F Works on ANY type with these methods (List, Option, Future, Try, IO, etc.)\n\nfor\n  x \u003C- List(1, 2, 3)                      \u002F\u002F generator → flatMap\n  if x % 2 == 0                           \u002F\u002F guard   → withFilter\n  y = x * x                               \u002F\u002F binding → map (assigns intermediate)\n  z \u003C- List(y, y + 1)                     \u002F\u002F generator → flatMap\nyield (x, y, z)\n\n\u002F\u002F Exact desugaring (what the compiler generates):\nList(1, 2, 3)\n  .withFilter(_ % 2 == 0)\n  .flatMap { x =>\n    val y = x * x                         \u002F\u002F binding becomes a map to pair (x, y)\n    List(y, y + 1).map { z => (x, y, z) }\n  }\n\u002F\u002F → List((2, 4, 4), (2, 4, 5))\n\n\u002F\u002F Monadic chaining across Option:\ndef compute(a: Option[Int], b: Option[Int]): Option[Int] =\n  for\n    x \u003C- a                                \u002F\u002F if a is None → entire comprehension is None\n    y \u003C- b                                \u002F\u002F if b is None → short-circuits to None\n    if x + y > 0                          \u002F\u002F guard\n  yield x + y                             \u002F\u002F map\n\n\u002F\u002F Equivalent:\na.flatMap(x => b.withFilter(y => x + y > 0).map(y => x + y))\n",[30,2740,2741,2746,2751,2755,2760,2788,2806,2823,2843,2851,2855,2860,2878,2893,2900,2920,2939,2944,2949,2953,2958,3008,3013,3026,3039,3058,3073,3077,3082],{"__ignoreMap":28},[33,2742,2743],{"class":35,"line":36},[33,2744,2745],{"class":39},"\u002F\u002F For-comprehension is NOT a loop — it's syntactic sugar for flatMap\u002Fmap\u002FwithFilter\n",[33,2747,2748],{"class":35,"line":43},[33,2749,2750],{"class":39},"\u002F\u002F Works on ANY type with these methods (List, Option, Future, Try, IO, etc.)\n",[33,2752,2753],{"class":35,"line":49},[33,2754,95],{"emptyLinePlaceholder":94},[33,2756,2757],{"class":35,"line":55},[33,2758,2759],{"class":101},"for\n",[33,2761,2762,2765,2768,2770,2772,2774,2776,2778,2780,2782,2785],{"class":35,"line":61},[33,2763,2764],{"class":124},"  x ",[33,2766,2767],{"class":101},"\u003C-",[33,2769,553],{"class":112},[33,2771,284],{"class":124},[33,2773,1047],{"class":136},[33,2775,194],{"class":124},[33,2777,1236],{"class":136},[33,2779,194],{"class":124},[33,2781,1241],{"class":136},[33,2783,2784],{"class":124},")                      ",[33,2786,2787],{"class":39},"\u002F\u002F generator → flatMap\n",[33,2789,2790,2792,2794,2797,2799,2801,2803],{"class":35,"line":67},[33,2791,2017],{"class":101},[33,2793,125],{"class":124},[33,2795,2796],{"class":101},"%",[33,2798,137],{"class":136},[33,2800,2583],{"class":101},[33,2802,2003],{"class":136},[33,2804,2805],{"class":39},"                           \u002F\u002F guard   → withFilter\n",[33,2807,2808,2811,2813,2815,2817,2820],{"class":35,"line":73},[33,2809,2810],{"class":124},"  y ",[33,2812,355],{"class":101},[33,2814,125],{"class":124},[33,2816,133],{"class":101},[33,2818,2819],{"class":124}," x                               ",[33,2821,2822],{"class":39},"\u002F\u002F binding → map (assigns intermediate)\n",[33,2824,2825,2828,2830,2832,2835,2837,2839,2841],{"class":35,"line":79},[33,2826,2827],{"class":124},"  z ",[33,2829,2767],{"class":101},[33,2831,553],{"class":112},[33,2833,2834],{"class":124},"(y, y ",[33,2836,1022],{"class":101},[33,2838,458],{"class":136},[33,2840,1380],{"class":124},[33,2842,2787],{"class":39},[33,2844,2845,2848],{"class":35,"line":85},[33,2846,2847],{"class":101},"yield",[33,2849,2850],{"class":124}," (x, y, z)\n",[33,2852,2853],{"class":35,"line":91},[33,2854,95],{"emptyLinePlaceholder":94},[33,2856,2857],{"class":35,"line":98},[33,2858,2859],{"class":39},"\u002F\u002F Exact desugaring (what the compiler generates):\n",[33,2861,2862,2864,2866,2868,2870,2872,2874,2876],{"class":35,"line":143},[33,2863,541],{"class":112},[33,2865,284],{"class":124},[33,2867,1047],{"class":136},[33,2869,194],{"class":124},[33,2871,1236],{"class":136},[33,2873,194],{"class":124},[33,2875,1241],{"class":136},[33,2877,780],{"class":124},[33,2879,2880,2883,2885,2887,2889,2891],{"class":35,"line":152},[33,2881,2882],{"class":124},"  .withFilter(_ ",[33,2884,2796],{"class":101},[33,2886,137],{"class":136},[33,2888,2583],{"class":101},[33,2890,2003],{"class":136},[33,2892,780],{"class":124},[33,2894,2895,2898],{"class":35,"line":161},[33,2896,2897],{"class":124},"  .flatMap { x ",[33,2899,1369],{"class":101},[33,2901,2902,2905,2908,2910,2912,2914,2917],{"class":35,"line":166},[33,2903,2904],{"class":101},"    val",[33,2906,2907],{"class":105}," y",[33,2909,121],{"class":101},[33,2911,125],{"class":124},[33,2913,133],{"class":101},[33,2915,2916],{"class":124}," x                         ",[33,2918,2919],{"class":39},"\u002F\u002F binding becomes a map to pair (x, y)\n",[33,2921,2922,2925,2927,2929,2931,2934,2936],{"class":35,"line":172},[33,2923,2924],{"class":112},"    List",[33,2926,2834],{"class":124},[33,2928,1022],{"class":101},[33,2930,458],{"class":136},[33,2932,2933],{"class":124},").map { z ",[33,2935,128],{"class":101},[33,2937,2938],{"class":124}," (x, y, z) }\n",[33,2940,2941],{"class":35,"line":178},[33,2942,2943],{"class":124},"  }\n",[33,2945,2946],{"class":35,"line":243},[33,2947,2948],{"class":39},"\u002F\u002F → List((2, 4, 4), (2, 4, 5))\n",[33,2950,2951],{"class":35,"line":248},[33,2952,95],{"emptyLinePlaceholder":94},[33,2954,2955],{"class":35,"line":254},[33,2956,2957],{"class":39},"\u002F\u002F Monadic chaining across Option:\n",[33,2959,2960,2962,2965,2967,2970,2972,2975,2977,2979,2982,2985,2987,2989,2991,2993,2995,2997,3000,3002,3004,3006],{"class":35,"line":266},[33,2961,316],{"class":101},[33,2963,2964],{"class":112}," compute",[33,2966,284],{"class":124},[33,2968,2969],{"class":105},"a",[33,2971,290],{"class":124},[33,2973,2974],{"class":112},"Option",[33,2976,304],{"class":124},[33,2978,191],{"class":112},[33,2980,2981],{"class":124},"], ",[33,2983,2984],{"class":105},"b",[33,2986,290],{"class":124},[33,2988,2974],{"class":112},[33,2990,304],{"class":124},[33,2992,191],{"class":112},[33,2994,548],{"class":124},[33,2996,109],{"class":101},[33,2998,2999],{"class":112}," Option",[33,3001,304],{"class":124},[33,3003,191],{"class":112},[33,3005,352],{"class":124},[33,3007,562],{"class":101},[33,3009,3010],{"class":35,"line":275},[33,3011,3012],{"class":101},"  for\n",[33,3014,3015,3018,3020,3023],{"class":35,"line":313},[33,3016,3017],{"class":124},"    x ",[33,3019,2767],{"class":101},[33,3021,3022],{"class":124}," a                                ",[33,3024,3025],{"class":39},"\u002F\u002F if a is None → entire comprehension is None\n",[33,3027,3028,3031,3033,3036],{"class":35,"line":658},[33,3029,3030],{"class":124},"    y ",[33,3032,2767],{"class":101},[33,3034,3035],{"class":124}," b                                ",[33,3037,3038],{"class":39},"\u002F\u002F if b is None → short-circuits to None\n",[33,3040,3041,3044,3046,3048,3051,3053,3055],{"class":35,"line":667},[33,3042,3043],{"class":101},"    if",[33,3045,125],{"class":124},[33,3047,1022],{"class":101},[33,3049,3050],{"class":124}," y ",[33,3052,2701],{"class":101},[33,3054,2003],{"class":136},[33,3056,3057],{"class":39},"                          \u002F\u002F guard\n",[33,3059,3060,3063,3065,3067,3070],{"class":35,"line":1056},[33,3061,3062],{"class":101},"  yield",[33,3064,125],{"class":124},[33,3066,1022],{"class":101},[33,3068,3069],{"class":124}," y                             ",[33,3071,3072],{"class":39},"\u002F\u002F map\n",[33,3074,3075],{"class":35,"line":1061},[33,3076,95],{"emptyLinePlaceholder":94},[33,3078,3079],{"class":35,"line":1067},[33,3080,3081],{"class":39},"\u002F\u002F Equivalent:\n",[33,3083,3084,3087,3089,3092,3094,3096,3098,3100,3102,3104,3107,3109,3111,3113],{"class":35,"line":1098},[33,3085,3086],{"class":124},"a.flatMap(x ",[33,3088,128],{"class":101},[33,3090,3091],{"class":124}," b.withFilter(y ",[33,3093,128],{"class":101},[33,3095,125],{"class":124},[33,3097,1022],{"class":101},[33,3099,3050],{"class":124},[33,3101,2701],{"class":101},[33,3103,2003],{"class":136},[33,3105,3106],{"class":124},").map(y ",[33,3108,128],{"class":101},[33,3110,125],{"class":124},[33,3112,1022],{"class":101},[33,3114,3115],{"class":124}," y))\n",[15,3117,3119],{"id":3118},"extension-methods-compile-time-injection","Extension Methods — Compile-Time Injection",[20,3121,3122],{"language":22},[24,3123,3125],{"className":26,"code":3124,"language":22,"meta":28,"style":28},"\u002F\u002F Extension methods in Scala 3 — no implicit conversion overhead\nextension (s: String)\n  def slug: String = s.toLowerCase.replaceAll(\"[^a-z0-9]+\", \"-\").stripSuffix(\"-\")\n  def truncate(max: Int): String = if s.length \u003C= max then s else s.take(max - 1) + \"…\"\n\n\"Hello World!!\".slug                      \u002F\u002F → \"hello-world\"\n\"A very long string here\".truncate(10)    \u002F\u002F → \"A very lon…\"\n\n\u002F\u002F Extension on generic type with context bound:\nextension [A](list: List[A])\n  def freqMap: Map[A, Int] = list.groupMapReduce(identity)(_ => 1)(_ + _)\n\nList(\"a\", \"b\", \"a\", \"c\", \"a\").freqMap     \u002F\u002F → Map(\"a\" -> 3, \"b\" -> 1, \"c\" -> 1)\n\n\u002F\u002F Extension compiles to a static method with the receiver as first param.\n\u002F\u002F \"Hello\".slug → StringExt$.MODULE$.slug$extension(\"Hello\")\n\u002F\u002F No wrapper object, no implicit conversion — zero runtime cost.\n",[30,3126,3127,3132,3148,3179,3232,3236,3247,3264,3268,3273,3297,3335,3339,3372,3376,3381,3386],{"__ignoreMap":28},[33,3128,3129],{"class":35,"line":36},[33,3130,3131],{"class":39},"\u002F\u002F Extension methods in Scala 3 — no implicit conversion overhead\n",[33,3133,3134,3137,3139,3142,3144,3146],{"class":35,"line":43},[33,3135,3136],{"class":101},"extension",[33,3138,188],{"class":124},[33,3140,3141],{"class":105},"s",[33,3143,290],{"class":124},[33,3145,197],{"class":112},[33,3147,780],{"class":124},[33,3149,3150,3152,3155,3157,3159,3161,3164,3167,3169,3172,3175,3177],{"class":35,"line":49},[33,3151,278],{"class":101},[33,3153,3154],{"class":112}," slug",[33,3156,109],{"class":101},[33,3158,1524],{"class":112},[33,3160,121],{"class":101},[33,3162,3163],{"class":124}," s.toLowerCase.replaceAll(",[33,3165,3166],{"class":858},"\"[^a-z0-9]+\"",[33,3168,194],{"class":124},[33,3170,3171],{"class":858},"\"-\"",[33,3173,3174],{"class":124},").stripSuffix(",[33,3176,3171],{"class":858},[33,3178,780],{"class":124},[33,3180,3181,3183,3186,3188,3190,3192,3194,3196,3198,3200,3202,3204,3207,3209,3211,3213,3216,3218,3221,3223,3225,3227,3229],{"class":35,"line":55},[33,3182,278],{"class":101},[33,3184,3185],{"class":112}," truncate",[33,3187,284],{"class":124},[33,3189,1723],{"class":105},[33,3191,290],{"class":124},[33,3193,191],{"class":112},[33,3195,296],{"class":124},[33,3197,109],{"class":101},[33,3199,1524],{"class":112},[33,3201,121],{"class":101},[33,3203,220],{"class":101},[33,3205,3206],{"class":124}," s.length ",[33,3208,2023],{"class":101},[33,3210,1773],{"class":124},[33,3212,226],{"class":101},[33,3214,3215],{"class":124}," s ",[33,3217,237],{"class":101},[33,3219,3220],{"class":124}," s.take(max ",[33,3222,1811],{"class":101},[33,3224,458],{"class":136},[33,3226,205],{"class":124},[33,3228,1022],{"class":101},[33,3230,3231],{"class":858}," \"…\"\n",[33,3233,3234],{"class":35,"line":61},[33,3235,95],{"emptyLinePlaceholder":94},[33,3237,3238,3241,3244],{"class":35,"line":67},[33,3239,3240],{"class":858},"\"Hello World!!\"",[33,3242,3243],{"class":124},".slug                      ",[33,3245,3246],{"class":39},"\u002F\u002F → \"hello-world\"\n",[33,3248,3249,3252,3255,3258,3261],{"class":35,"line":73},[33,3250,3251],{"class":858},"\"A very long string here\"",[33,3253,3254],{"class":124},".truncate(",[33,3256,3257],{"class":136},"10",[33,3259,3260],{"class":124},")    ",[33,3262,3263],{"class":39},"\u002F\u002F → \"A very lon…\"\n",[33,3265,3266],{"class":35,"line":79},[33,3267,95],{"emptyLinePlaceholder":94},[33,3269,3270],{"class":35,"line":85},[33,3271,3272],{"class":39},"\u002F\u002F Extension on generic type with context bound:\n",[33,3274,3275,3277,3280,3282,3284,3286,3288,3290,3292,3294],{"class":35,"line":91},[33,3276,3136],{"class":101},[33,3278,3279],{"class":124}," [",[33,3281,1169],{"class":112},[33,3283,1177],{"class":124},[33,3285,1180],{"class":105},[33,3287,290],{"class":124},[33,3289,541],{"class":112},[33,3291,304],{"class":124},[33,3293,1169],{"class":112},[33,3295,3296],{"class":124},"])\n",[33,3298,3299,3301,3304,3306,3309,3311,3313,3315,3317,3319,3321,3324,3326,3328,3330,3332],{"class":35,"line":98},[33,3300,278],{"class":101},[33,3302,3303],{"class":112}," freqMap",[33,3305,109],{"class":101},[33,3307,3308],{"class":112}," Map",[33,3310,304],{"class":124},[33,3312,1169],{"class":112},[33,3314,194],{"class":124},[33,3316,191],{"class":112},[33,3318,352],{"class":124},[33,3320,355],{"class":101},[33,3322,3323],{"class":124}," list.groupMapReduce(identity)(_ ",[33,3325,128],{"class":101},[33,3327,458],{"class":136},[33,3329,1019],{"class":124},[33,3331,1022],{"class":101},[33,3333,3334],{"class":124}," _)\n",[33,3336,3337],{"class":35,"line":143},[33,3338,95],{"emptyLinePlaceholder":94},[33,3340,3341,3343,3345,3348,3350,3353,3355,3357,3359,3362,3364,3366,3369],{"class":35,"line":152},[33,3342,541],{"class":112},[33,3344,284],{"class":124},[33,3346,3347],{"class":858},"\"a\"",[33,3349,194],{"class":124},[33,3351,3352],{"class":858},"\"b\"",[33,3354,194],{"class":124},[33,3356,3347],{"class":858},[33,3358,194],{"class":124},[33,3360,3361],{"class":858},"\"c\"",[33,3363,194],{"class":124},[33,3365,3347],{"class":858},[33,3367,3368],{"class":124},").freqMap     ",[33,3370,3371],{"class":39},"\u002F\u002F → Map(\"a\" -> 3, \"b\" -> 1, \"c\" -> 1)\n",[33,3373,3374],{"class":35,"line":161},[33,3375,95],{"emptyLinePlaceholder":94},[33,3377,3378],{"class":35,"line":166},[33,3379,3380],{"class":39},"\u002F\u002F Extension compiles to a static method with the receiver as first param.\n",[33,3382,3383],{"class":35,"line":172},[33,3384,3385],{"class":39},"\u002F\u002F \"Hello\".slug → StringExt$.MODULE$.slug$extension(\"Hello\")\n",[33,3387,3388],{"class":35,"line":178},[33,3389,3390],{"class":39},"\u002F\u002F No wrapper object, no implicit conversion — zero runtime cost.\n",[15,3392,3394],{"id":3393},"tips-tricks","💡 Tips & Tricks",[3396,3397,3398,290,3402,3405,3406,3409,3410,3412,3413,3416,3417,3420],"p",{},[3399,3400,3401],"strong",{},"Eta-expansion for method-to-function",[30,3403,3404],{},"def f(x: Int) = x * 2"," → ",[30,3407,3408],{},"f _"," or just ",[30,3411,1194],{}," (Scala 3) converts to ",[30,3414,3415],{},"Int => Int",". One ",[30,3418,3419],{},"Function1"," allocation.",[3396,3422,3423,3429,3430,3433],{},[3399,3424,3425,3428],{},[30,3426,3427],{},"inline"," for zero-cost higher-order functions",": Scala 3 ",[30,3431,3432],{},"inline def"," eliminates the lambda allocation entirely — the function body is spliced at the call site.",[20,3435,3436],{"language":22},[24,3437,3439],{"className":26,"code":3438,"language":22,"meta":28,"style":28},"inline def mapInRange(start: Int, end: Int)(inline f: Int => Int): List[Int] =\n  var i = start\n  var acc = List.empty[Int]\n  while i \u003C= end do\n    acc = f(i) :: acc                      \u002F\u002F f is inlined here — NO lambda object\n    i += 1\n  acc.reverse\n\u002F\u002F mapInRange(1, 5)(_ * 2) → the while loop with `i * 2` inlined, zero Function1 allocation\n",[30,3440,3441,3497,3509,3527,3540,3559,3568,3573],{"__ignoreMap":28},[33,3442,3443,3445,3448,3451,3453,3455,3457,3459,3461,3464,3466,3468,3470,3472,3475,3477,3479,3481,3483,3485,3487,3489,3491,3493,3495],{"class":35,"line":36},[33,3444,3427],{"class":101},[33,3446,3447],{"class":101}," def",[33,3449,3450],{"class":112}," mapInRange",[33,3452,284],{"class":124},[33,3454,403],{"class":105},[33,3456,290],{"class":124},[33,3458,191],{"class":112},[33,3460,194],{"class":124},[33,3462,3463],{"class":105},"end",[33,3465,290],{"class":124},[33,3467,191],{"class":112},[33,3469,332],{"class":124},[33,3471,3427],{"class":101},[33,3473,3474],{"class":105}," f",[33,3476,290],{"class":124},[33,3478,191],{"class":112},[33,3480,116],{"class":101},[33,3482,113],{"class":112},[33,3484,296],{"class":124},[33,3486,109],{"class":101},[33,3488,553],{"class":112},[33,3490,304],{"class":124},[33,3492,191],{"class":112},[33,3494,352],{"class":124},[33,3496,562],{"class":101},[33,3498,3499,3501,3504,3506],{"class":35,"line":43},[33,3500,426],{"class":101},[33,3502,3503],{"class":105}," i",[33,3505,121],{"class":101},[33,3507,3508],{"class":124}," start\n",[33,3510,3511,3513,3516,3518,3520,3523,3525],{"class":35,"line":49},[33,3512,426],{"class":101},[33,3514,3515],{"class":105}," acc",[33,3517,121],{"class":101},[33,3519,553],{"class":112},[33,3521,3522],{"class":124},".empty[",[33,3524,191],{"class":112},[33,3526,310],{"class":124},[33,3528,3529,3531,3533,3535,3538],{"class":35,"line":55},[33,3530,1764],{"class":101},[33,3532,229],{"class":124},[33,3534,2023],{"class":101},[33,3536,3537],{"class":124}," end ",[33,3539,1776],{"class":101},[33,3541,3542,3545,3547,3550,3553,3556],{"class":35,"line":61},[33,3543,3544],{"class":124},"    acc ",[33,3546,355],{"class":101},[33,3548,3549],{"class":124}," f(i) ",[33,3551,3552],{"class":101},"::",[33,3554,3555],{"class":124}," acc                      ",[33,3557,3558],{"class":39},"\u002F\u002F f is inlined here — NO lambda object\n",[33,3560,3561,3564,3566],{"class":35,"line":67},[33,3562,3563],{"class":124},"    i ",[33,3565,455],{"class":101},[33,3567,1822],{"class":136},[33,3569,3570],{"class":35,"line":73},[33,3571,3572],{"class":124},"  acc.reverse\n",[33,3574,3575],{"class":35,"line":79},[33,3576,3577],{"class":39},"\u002F\u002F mapInRange(1, 5)(_ * 2) → the while loop with `i * 2` inlined, zero Function1 allocation\n",[3396,3579,3580,290,3585,3588,3589,3592,3593,723],{},[3399,3581,3582,3584],{},[30,3583,3419],{}," composition avoids intermediate collections",[30,3586,3587],{},"(f andThen g andThen h)(list)"," when combined with ",[30,3590,3591],{},"list.map"," fuses into a single pass if the functions are ",[30,3594,3595],{},"@inline",[15,3597,3599],{"id":3598},"️-edge-cases-gotchas","⚠️ Edge Cases & Gotchas",[3396,3601,3602,3609],{},[3399,3603,3604,3605,3608],{},"Closure captures ",[30,3606,3607],{},"var"," by reference, not value",": If you mutate the captured var after creating the closure, the closure sees the new value. This is the source of classic loop-capture bugs.",[20,3611,3612],{"language":22},[24,3613,3615],{"className":26,"code":3614,"language":22,"meta":28,"style":28},"var x = 0\nval closures = (1 to 3).map { i =>\n  () => (x, i)                             \u002F\u002F captures x (the var) and i (the val)\n}\nx = 99\nclosures.map(_())                          \u002F\u002F → List((99,1), (99,2), (99,3)) — x is 99 everywhere!\n\u002F\u002F i is fine — it's a loop val, each iteration gets its own binding\n",[30,3616,3617,3628,3651,3663,3667,3677,3685],{"__ignoreMap":28},[33,3618,3619,3621,3624,3626],{"class":35,"line":36},[33,3620,3607],{"class":101},[33,3622,3623],{"class":105}," x",[33,3625,121],{"class":101},[33,3627,1759],{"class":136},[33,3629,3630,3632,3635,3637,3639,3641,3644,3646,3649],{"class":35,"line":43},[33,3631,102],{"class":101},[33,3633,3634],{"class":105}," closures",[33,3636,121],{"class":101},[33,3638,188],{"class":124},[33,3640,1047],{"class":136},[33,3642,3643],{"class":124}," to ",[33,3645,1241],{"class":136},[33,3647,3648],{"class":124},").map { i ",[33,3650,1369],{"class":101},[33,3652,3653,3655,3657,3660],{"class":35,"line":49},[33,3654,442],{"class":124},[33,3656,128],{"class":101},[33,3658,3659],{"class":124}," (x, i)                             ",[33,3661,3662],{"class":39},"\u002F\u002F captures x (the var) and i (the val)\n",[33,3664,3665],{"class":35,"line":55},[33,3666,1388],{"class":124},[33,3668,3669,3672,3674],{"class":35,"line":61},[33,3670,3671],{"class":124},"x ",[33,3673,355],{"class":101},[33,3675,3676],{"class":136}," 99\n",[33,3678,3679,3682],{"class":35,"line":67},[33,3680,3681],{"class":124},"closures.map(_())                          ",[33,3683,3684],{"class":39},"\u002F\u002F → List((99,1), (99,2), (99,3)) — x is 99 everywhere!\n",[33,3686,3687],{"class":35,"line":73},[33,3688,3689],{"class":39},"\u002F\u002F i is fine — it's a loop val, each iteration gets its own binding\n",[3396,3691,3692,3697,3698,3701,3702,2577,3705,3708],{},[3399,3693,3694,3696],{},[30,3695,1919],{}," fails on try\u002Fcatch",": A ",[30,3699,3700],{},"try"," block prevents tail-call optimization because the exception handler needs the stack frame. Use ",[30,3703,3704],{},"Either",[30,3706,3707],{},"Try"," instead of try\u002Fcatch inside recursive functions.",[3396,3710,3711,3714,3715,3718],{},[3399,3712,3713],{},"Default parameter values are evaluated at call time, not definition time",": Unlike Python (which evaluates defaults once at def time), Scala re-evaluates defaults on each call. So ",[30,3716,3717],{},"def f(buf: List[Int] = List())"," is safe — no shared mutable default.",[15,3720,3722],{"id":3721},"quick-quiz","🧠 Quick Quiz",[3396,3724,3725,3726,3729,3730,3733],{},"Why does ",[30,3727,3728],{},"List(1,2,3).map(println).map(_ * 2)"," print three numbers but the result is ",[30,3731,3732],{},"List((), (), ())","?",[3735,3736,3737,3741,3770,3788],"details",{},[3738,3739,3740],"summary",{},"Answer",[3396,3742,3743,3746,3747,3749,3750,3753,3754,3756,3757,3759,3760,3763,3764,3766,3767,3769],{},[30,3744,3745],{},"println"," returns ",[30,3748,2661],{},". So ",[30,3751,3752],{},"List(1,2,3).map(println)"," produces ",[30,3755,3732],{}," — it prints each number (side effect) but the elements are now ",[30,3758,2661],{},". The second ",[30,3761,3762],{},".map(_ * 2)"," will fail to compile because ",[30,3765,2661],{}," has no ",[30,3768,133],{}," method.",[3396,3771,3772,3773,3775,3776,3778,3779,3782,3783,3785,3786,723],{},"If this compiled (e.g., with ",[30,3774,2656],{}," typing), the result would be ",[30,3777,3732],{}," — the ",[30,3780,3781],{},"_ * 2"," is never reached because ",[30,3784,2661],{}," doesn't support ",[30,3787,133],{},[3396,3789,3790,290,3793,3795,3796,3799,3800,723],{},[3399,3791,3792],{},"Lesson",[30,3794,2730],{}," is for transforming values, not side effects. Use ",[30,3797,3798],{},"foreach"," for side effects: ",[30,3801,3802],{},"List(1,2,3).foreach(println)",[3804,3805,3806],"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 .sCrzJ, html code.shiki .sCrzJ{--shiki-default:#E36209;--shiki-github-dark:#FFAB70}html pre.shiki code .sIsaT, html code.shiki .sIsaT{--shiki-default:#6F42C1;--shiki-github-dark:#B392F0}html pre.shiki code .ssxIu, html code.shiki .ssxIu{--shiki-default:#24292E;--shiki-github-dark:#E1E4E8}html pre.shiki code .snvgF, html code.shiki .snvgF{--shiki-default:#005CC5;--shiki-github-dark:#79B8FF}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);}html pre.shiki code .sJ6F3, html code.shiki .sJ6F3{--shiki-default:#032F62;--shiki-github-dark:#9ECBFF}",{"title":28,"searchDepth":43,"depth":43,"links":3808},[3809,3810,3811,3812,3813,3815,3817,3819,3821,3822,3823,3824],{"id":17,"depth":43,"text":18},{"id":364,"depth":43,"text":365},{"id":699,"depth":43,"text":700},{"id":1120,"depth":43,"text":1121},{"id":1479,"depth":43,"text":3814},"By-Name Parameters (=> T) vs By-Need (=> T with lazy)",{"id":1915,"depth":43,"text":3816},"Tail Recursion — @tailrec & Loop Desugaring",{"id":2349,"depth":43,"text":3818},"Partial Functions — PartialFunction[A, B]",{"id":2722,"depth":43,"text":3820},"For-Comprehension — Desugared to flatMap \u002F map \u002F filter",{"id":3118,"depth":43,"text":3119},{"id":3393,"depth":43,"text":3394},{"id":3598,"depth":43,"text":3599},{"id":3721,"depth":43,"text":3722},"Production deep-dive into function types, closure capturing, tail-call optimization, by-name vs by-need, currying, and the JVM representation of Scala functions.","md",{},"\u002Fscala\u002F03-functions",{"title":5,"description":3825},"scala\u002F03-functions","01pzJIofFBNKXvANpfRBHLMpXOc6CGD-zweRSJaVfew",1789924653949]