Challenge 3: Why a Lambda Is Not a New Language Feature at Its Core — Possible Solution
====================================================================

Per the chapter, a lambda expression is compiler-generated SYNTACTIC
SUGAR for an anonymous class -- one with the lambda's captured
variables stored as ordinary member fields, and the lambda's own body
placed inside an overloaded `operator()` method. This is precisely
cpp1-6's own operator overloading mechanism: that chapter taught how to
give a custom class a callable-looking syntax by overloading
`operator()`, and a lambda is nothing more than the compiler
AUTOMATICALLY generating exactly that pattern, on the programmer's
behalf, every time a `[capture](params) { body }` expression is
written.

Concretely, per the chapter's own translation example: `[x](int y) {
return x + y; }` is roughly equivalent to hand-writing a class with an
`int x` member field, a constructor that initializes it from the
captured variable, and an `operator()(int y)` method containing the
lambda's body -- calling the lambda (`myLambda(5)`) is, under the hood,
genuinely calling `operator()` on an instance of that generated class,
exactly the same call syntax cpp1-6 already established for any class
overloading that operator.

This is why lambdas are "not a new language feature at their core":
nothing about how a lambda actually WORKS once compiled introduces any
mechanism the language didn't already have -- classes, member fields,
constructors, and operator overloading were all already fully
established by Course 1. A lambda's genuine contribution is purely
SYNTACTIC CONVENIENCE -- letting a programmer write that entire
class-plus-operator()-plus-constructor pattern in one compact
expression, inline, at the exact point it's needed, rather than having
to define a full named class separately every time a small, one-off
callable is needed.

WHY THIS WORKS AS AN ANSWER
------------------------------
This traces the lambda's compiled form directly back to cpp1-6's own
operator() material by name, explains the specific translation (capture
-> member field, body -> operator() implementation), and correctly
frames the lambda's real contribution as syntactic convenience over an
already-existing mechanism, not a genuinely new capability.